# BEGIN_ICS_COPYRIGHT8 ****************************************
#
# Copyright (c) 2015-2020, Intel Corporation
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#     * Redistributions of source code must retain the above copyright notice,
#       this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above copyright
#       notice, this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
#     * Neither the name of Intel Corporation nor the names of its contributors
#       may be used to endorse or promote products derived from this software
#       without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# END_ICS_COPYRIGHT8   ****************************************

# [ICS VERSION STRING: @(#) ./fastfabric/tools/extmng.exp 10_4_0_0_168 [03/04/17 07:32]

# This is an expect (tcl) library of procedures to aid OPASW operations

## tcl procedures to support testing:
## =============================================

proc expect_list_with_punchlist { ibnode issue timelimit list { error_list "" } { out_var "" } } {
	if { ! [ string equal "$out_var" "" ] } {
		upvar $out_var out
		set var "out"
	} else {
		set var ""
	}

	if { [ catch { set res [ expect_list $timelimit $list $error_list $var ] } err_str ] != 0 } {
		append_punchlist "$ibnode" "$issue"
		error "$err_str"
	}
	return $res
}

proc trim_opaswitch_distance { opaswitch } {
##
## trim_opaswitch_distance
## ---------------------------
## remove the ,distance from the opaswitch
##
## Usage:
##	trim_opaswitch_distance opaswitch
## Arguments:
##	opaswitch - node to resolve, syntax as found in opaswitchs file
## Returns:
##	opaswitch with any ,distance field removed
##	-code error on failure
## Additional Information:
##	Syntax allowed for opaswitch:
##		nodeguid
##		nodeguid,,distance
##		nodeguid:hfi:port
##		nodeguid:hfi:port,,distance
##		nodeguid,nodename
##		nodeguid,nodename,distance
##		nodeguid:hfi:port,nodename
##		nodeguid:hfi:port,nodename,distance
##
	global env

	set index [string first "," "$opaswitch" ]
	if { $index != -1 } {
		set index [string first "," "$opaswitch" [ expr $index + 1]]
		if { $index != -1 } {
			# remove ,distance
			set opaswitch [string range "$opaswitch" 0 [ expr $index - 1] ]
		}
	}
	return "$opaswitch"
}

proc get_opaswitch_distance { opaswitch } {
##
## gettrim_opaswitch_distance
## ---------------------------
## get the distance from the opaswitch
##
## Usage:
##	get_opaswitch_distance opaswitch
## Arguments:
##	opaswitch - node to process, syntax as found in switches file
## Returns:
##	distance field from opaswitch or ""
##	-code error on failure
## Additional Information:
##	Syntax allowed for opaswitch:
##		nodeguid
##		nodeguid,,distance
##		nodeguid:hfi:port
##		nodeguid:hfi:port,,distance
##		nodeguid,nodename
##		nodeguid,nodename,distance
##		nodeguid:hfi:port,nodename
##		nodeguid:hfi:port,nodename,distance
##
	global env

	set index [string first "," "$opaswitch" ]
	if { $index != -1 } {
		set index [string first "," "$opaswitch" [ expr $index + 1]]
		if { $index != -1 } {
			# return distance
			return [string range "$opaswitch" [expr $index + 1 ] end ]
		}
	}
	return ""
}

proc trim_opaswitch_hfi_port { opaswitch } {
##
## trim_opaswitch_hfi_port
## ---------------------------
## remove the hfi:port from the opaswitch
##
## Usage:
##	trim_opaswitch_hfi_port opaswitch
## Arguments:
##	opaswitch - node to resolve, syntax as found in opaswitchs file
## Returns:
##	opaswitch with any hfi:port field removed
##	-code error on failure
## Additional Information:
##	Assumes ,distance was already removed from opaswitch
##	Syntax allowed for opaswitch:
##		nodeguid
##		nodeguid:hfi:port
##		nodeguid,nodename
##		nodeguid:hfi:port,nodename
##
	global env

	# first parse off any nodename
	set index [string first "," "$opaswitch" ]
	if { $index != -1 } {
		# includes ,
		set nodename [string range "$opaswitch" $index end ]
		# excludes ,
		set nodeguid_hfi_port [string range "$opaswitch" 0 [ expr $index - 1] ]
	} else {
		set nodename ""
		set nodeguid_hfi_port "$opaswitch"
	}
	# now parse off any hfi_port
	set index [string first ":" "$nodeguid_hfi_port" ]
	if { $index != -1 } {
		# excludes :
		set hfi_port [string range "$nodeguid_hfi_port" [expr $index + 1] end ]
		# excludes :
		set nodeguid [string range "$nodeguid_hfi_port" 0 [ expr $index - 1] ]
	} else {
		set hfi_port ""
		set nodeguid "$nodeguid_hfi_port"
	}
	return "$nodeguid$nodename"
}

proc strip_nodename_from_guid { opaswitch } {
##
## strip_nodename_from_guid
## ---------------------------
## remove the nodename from the opaswitch
##
## Usage:
##	strip_nodename_from_guid opaswitch
## Arguments:
##	opaswitch - node representation guid followed optionally
##     by comma and nodename
## Returns:
##	opaswitch with comma and nodename removed
## Additional Information:
##	Assumes ,distance was already removed from opaswitch
##
	global env

	set index [string first "," "$opaswitch" ]
	if { $index != -1 } {
		set node_guid [string range "$opaswitch" 0 [ expr $index - 1 ] ]
	} else {
		set node_guid "$opaswitch"
	}
	return "$node_guid"
}

proc strip_nodeguid_from_desc { ibnode } {
##
## strip_nodeguid_from_desc
## ---------------------------
## remove the node GUID from the ibnode
##
## Usage:
##	strip_nodeguid_from_desc ibnode
## Arguments:
##	ibnode - node representation guid followed optionally
##     by comma and nodename
## Returns:
##	ibnode with node guid and comma removed
## Additional Information:
##	Assumes ,distance was already removed from ibnode
##
	global env

	set index [string first "," "$ibnode" ]
	if { $index != -1 } {
		set node_desc [string range "$ibnode" [ expr $index + 1  ] [expr [string length "$ibnode"]] ]
	} else {
		set node_desc ""
	}
	return "$node_desc"
}

proc resolve_ibnode { ibnode } {
##
## resolve_ibnode
## ---------------------------
## resolve the hfi:port by which the given ibnode should be accessed
##
## Usage:
##	resolve_ibnode ibnode
## Arguments:
##	ibnode - node to resolve, syntax as found in ibnodes file
## Returns:
##	hfi:port to access ibnode via -> success
##	-code error on failure
## Additional Information:
##	Assumes ,distance was already removed from ibnode
##	Must be called with a local_sh established
##	env(CFG_PORTS) is used to specify local hfi:port(s) to check to
##	locate ibnode if ibnode does not have an explicit hfi_port.
##	Syntax allowed for ibnode:
##		nodeguid
##		nodeguid:hfi:port
##		nodeguid,nodename
##		nodeguid:hfi:port,nodename
##
	global env

	set bindir /usr/sbin

	# first parse off any nodename
	set index [string first "," "$ibnode" ]
	if { $index != -1 } {
		# excludes ,
		set nodeguid_hfi_port [string range "$ibnode" 0 [ expr $index - 1] ]

	} else {
		set nodeguid_hfi_port "$ibnode"
	}
	# now parse off any hfi_port
	set index [string first ":" "$nodeguid_hfi_port" ]
	if { $index != -1 } {
		# excludes :
		set hfi_port [string range "$nodeguid_hfi_port" [expr $index + 1] end ]
		# excludes :
		set nodeguid [string range "$nodeguid_hfi_port" 0 [ expr $index - 1] ]
	} else {
		set hfi_port ""
		set nodeguid "$nodeguid_hfi_port"
	}

	if { [ string equal "$hfi_port" "" ] } {
		# no hfi_port specified
		set found 0
		set llen [ llength $env(CFG_PORTS) ]
		if { $llen == 0 } {
			# default should have been set in opatest.sh, just be safe
			set hfi_port "0:0"
		} elseif { $llen == 1 } {
			# no use iterating saquery, only 1 choice
			set hfi_port [ lindex $env(CFG_PORTS) 0 ]
		} else {
			# iterate all specified ports, find first with given ibnode
			foreach hfi_port $env(CFG_PORTS) {
				set hfi_port_args [ get_hfi_port_args "$hfi_port" "-p" ]
				# if saquery outputs a Node Record (which includes PortGuid heading)
				# the nodeguid was found.  Otherwise it will output an error message
				if { ! [ string equal "$hfi_port" [ lindex $env(CFG_PORTS) 0] ] } {
					log_message("Retrying with HFI port $hfi_port");
				}
				if { [ catch { unix_cmd 90 0 "$bindir/opasaquery $hfi_port_args -n $nodeguid 2>&1|grep -i PortGuid > /dev/null 2>&1" } res ] == 0 } {
					set found 1
					break
				} else {
					# kill any stuck saquery command
					target_send_intr
					expect_unix_prompt 60
				}
			}
			if { ! $found } {
				append_punchlist "$ibnode" "Unable to find via hfi:port(s) $env(CFG_PORTS)"
				fail_test "Unable to find $ibnode via hfi:port(s) $env(CFG_PORTS)"
			}
		}
	}
	return "$hfi_port"
}

proc get_hfi_port_args { hfi_port { port_arg "-o" }} {
##
## get_hfi_port_args
## -------------------
## parse the hfi_port and return proper -h and -o options for commands
##
## Usage:
##	get_hfi_port_args hfi_port [port_arg]
## Arguments:
##	hfi_port - hfi:port on local system to use to access the switch
##				if "", defaults to 1st local port
##	port_arg - argument name to specify port (default is p)
## Returns:
##	nothing
## Additional Information:
##	

	if { [ string equal "$hfi_port" "" ] } {
		set hfi_port "0:0"
	}
	set hfi ""
	set port ""
	regexp {([0-9]+):([0-9]+)} $hfi_port p1 hfi port
	if { [ string equal "$hfi" ""] || [ string equal "$port" ""] } {
		fail_test "Invalid hfi:port ($hfi_port)"
	}
	set hfi_port_args "-h $hfi"
	if { ! [ string equal "$port" "0"] } {
		set hfi_port_args "$hfi_port_args $port_arg $port"
	}
	return "$hfi_port_args"
}

proc get_switch_type { ibnode sa_hfi_port_args node_guid } {
##
## get_switch_type
## -------------------
## find out if the switch is externally managed or internally managed 
##
## Usage:
##	ibnode sa_hfi_port_args node_guid	
## Arguments:
##		ibnode : to verify if it's a switch or not 
##		sa_hfi_port_args :  port on the local system to access switch 
##		node_guid : to query records and find details about switch
## Returns:
##	nothing
## Additional Information:

	global env

	set bindir /usr/sbin

	local_sh

	set type ""
	set out ""
	set lid ""
	set systemimageguid ""

	send_unix_cmd "$bindir/opasaquery $sa_hfi_port_args -n $node_guid"
	set out [expect_list_with_punchlist "$ibnode" "Switch not found in SA DB"  120 { "Type: [A-Za-z]+" } { "Error" "No Records Returned"}]
	regexp {([Type:]+) ([A-Za-z]+)} $out type2 type1 type
	check_exit_status 60 0
	send_unix_cmd "opasaquery $sa_hfi_port_args -n $node_guid -o node"
	set out [expect_list_with_punchlist "$ibnode" "Switch not found in SA DB"  120 { "SystemImageGuid: [0x[A-Fa-f0-9]+" } { "Error" "No Records Returned"}]
	regexp {(0x[A-Fa-f0-9]+)} $out systemimageguid 
	check_exit_status 60 0
	send_unix_cmd "opasaquery $sa_hfi_port_args -n $node_guid -o node"
	set out [expect_list_with_punchlist "$ibnode" "Switch not found in SA DB"  120 { "LID: [0x[A-Fa-f0-9]+" } { "Error" "No Records Returned"}]
	regexp {([LID:]+) ([0x[A-Fa-f0-9]+)} $out lid2 lid1 lid
	if { ! [ string equal "$type" "SW"] } {
		set type "SW"
		log_message "$ibnode: Not a Switch device"
		append_punchlist "$ibnode" "Not a Switch device"
		fail_test "$ibnode: Not a Switch device"
	} else {
		check_exit_status 60 0
		# TODO: does this need to be updated, and how so
		if { [ catch { unix_cmd 90 0 "echo $node_guid 2>&1 | grep 0x001175 /dev/null 2>&1" } res ] != 0 } {
			log_message "It's an Intel switch $node_guid"
		} else {
			log_message "It's not an Intel switch $node_guid"
		}
		check_exit_status 60 0
		if { [ catch { unix_cmd 90 0 "$bindir/opasaquery -l $lid -o portinfo 2>&1 | sed -n '/PortNum: *0x00/,/-------/p' 2>&1 | grep Capability: 2>&1 | grep -v VDR > /dev/null 2>&1 " } res ] == 0 } {
			log_message "$node_guid is an Internally Managed Switch"
			show_message "$node_guid is an Internally Managed Switch"
			append_punchlist "$ibnode" "Internally Managed Switch"
			fail_test "Not supported: This is not an externally managed switch"
		}	
	}
}

proc get_switch_brand { ibnode } {
##
## get_switch_brand
## -------------------
## determine if the switch identified by ibnode is OPA
##
## Usage:
##	get_switch_brand hfi_port [port_arg]
## Arguments:
##	hfi_port - hfi:port on local system to use to access the switch
##				if "", defaults to 1st local port
##	port_arg - argument name to specify port (default is p)
## Returns:
##	switch brand - "OPA" or "unknown"
## Additional Information:
##	
		global env

		local_sh

		set out ""
		set node_guid ""
		set deviceid ""
		set vendorid ""
		set brand ""
		set type "" 
		set bypass ""

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
        # use verbose option so we have a predictable output to expect
		set node_guid [ strip_nodename_from_guid "$trimmed_ibnode" ]
		set sa_hfi_port_args [ regsub -- "-o" "$hfi_port_args" "-p" ]
		set bypass $env(CFG_SWITCH_BYPASS_SWITCH_CHECK)
		if { [ string equal "$bypass" "n"] } {
			set type [ get_switch_type "$ibnode" "$sa_hfi_port_args" "$node_guid" ]
		} else {
			log_message ""
			log_message "Bypassing check for externally managed switch for -B option"
		}
		send_unix_cmd "opasaquery $sa_hfi_port_args -n $node_guid"
		set out [expect_list_with_punchlist "$ibnode" "Switch not found in SA DB"  120 { "VendorID: [A-Fa-fx0-9]+ DeviceId: [A-Fa-fx0-9]+" } { "Error" "No Records Returned" }]
		regexp {VendorID: (0x[A-Fa-f0-9]+) DeviceId: (0x[A-Fa-f0-9]+)} $out match vendorid deviceid
		if { [ string equal "$deviceid" "0xabc0"] } {
			if { [ string equal "$vendorid" "0x8086"] } {
				set brand "OPA"
				log_message "$ibnode: detected Intel OPA device"
			} else {
				set brand "unknown"
				log_message "$ibnode: detected unknown device"
			}
		} else {
			set brand "unknown"
			log_message "$ibnode: detected unknown device"
		}

		return "$brand"
}

proc get_switch_getportconfig { ibnode } {
##
## get_switch_getportconfig
## -------------------
## execute a test case gathering port info of switch  $ibnode
##
## Usage:
##	get_switch_getportconfig ibnode
## Arguments:
##	ibnode - ib node to get switch port config
## Returns:
##	config description
## Additional Information:
##	

		global env

		set toolsdir /usr/lib/opa/tools

		set out_msg ""

		local_sh
		set out ""

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
        # use verbose option so we have a predictable output to expect

		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } {
		check_exit_status 60 0
		send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 11 "
			set all [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "Switch.+opaswquery completed" } { "Error"}]
			regexp {(Switch configuration values)(.+)(opaswquery completed)} $all a b out_msg
			show_message "$out_msg"
		} else {
			append_punchlist "$ibnode" "Not an Intel Device"
			fail_test "$ibnode: Not an Intel Device"
		}

		local_sh_exit

		return "$out_msg"
}

proc get_portstate { ibnode } {
##
## get_portstate
## -------------------
## get state of local HFI port
##
## Usage:
##	get_portstate ibnode
## Arguments:
##	ibnode - ib node of switch, includes hfi/port
## Returns:
##	port state as output in "opaportinfo" command
## Additional Information:
##	
		global env
		set out_msg ""

		local_sh
		set out ""
		set portstate ""

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]

		send_unix_cmd "opaportinfo $hfi_port_args"
		set out [expect_list_with_punchlist "$ibnode" "Unable to open hfi:port"  30 { "PortState: +[A-Za-z]+" } { "failed"}]
		regexp {PortState: +([A-Za-z]+)} $out xx portstate

		local_sh_exit

		return "$portstate"
}

proc verify_port_active { ibnode {wait_time 30} } {
##
## verify_port_active
## -------------------
## verify that the local HFI port is active
##
## Usage:
##	verify_port_active ibnode <wait_time>
## Arguments:
##	ibnode - ib node of switch, includes hfi/port
##	wait_time - seconds to wait for the hfi port
##    to come active, default 30 
## Returns:
##	0 on success, -1 on failure
## Additional Information:
##	
		global env

		for {set i 0} {$i < $wait_time} {incr i} {
			set portstate [get_portstate "$ibnode"]
			set index [ string first "Active" $portstate ]
			if { $index == -1 } {
				sleep 1
			} else {
				return 0
			}
		}
		return -1
}


proc get_switch_info { ibnode } {
##
## get_switch_info
## -------------------
## execute a test case gathering switch info from $ibnode
##
## Usage:
##	get_switch_info ibnode
## Arguments:
##	ibnode - ib node to get switch info
## Returns:
##	info description
## Additional Information:
##	

		global env

		set toolsdir /usr/lib/opa/tools

		set out_msg ""

		local_sh

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
        # use verbose option so we have a predictable output to expect

		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } {
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 3"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "FW Version is [0-9.]+" } { "Error"}]
			regexp {([0-9.]+)} $out fwversion
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}

        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 11"
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "Switch configuration values" "[[:space:]]+Link Width[[:space:]]+[:][[:space:]][[:print:]]*([0-9]+)" } { "Error"}]
		regexp {[[:space:]]+Link Width[[:space:]]+[:][[:space:]]+([[:print:]],)*([0-9]+)} $out line p1 linkWidth
		set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "[[:space:]]+Link Speed[[:space:]]+[:][[:space:]]+([0-9Gb.,])*([0-9Gb]+)" } { "Error"}]
		regexp {[[:space:]]+Link Speed[[:space:]]+[:][[:space:]]+([[:print:]],)*([0-9Gb]+)$} $out line p1 linkSpeed
		set capability [format {%sx%s} $linkWidth $linkSpeed]

        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 4"
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "VPD \"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]+\",\"[[:print:]]+\",\"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]*\"" } { "Error"}]
		regexp {([VPD]+) "([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)"} $out p1 p2 p3 partnumber p4 hwversion

        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			set index1 [expr [string first "-" $partnumber ] + 1]
			set index2 [expr [string last "-" $partnumber ] - 1]
			set midNum [string range $partnumber $index1 $index2]
			set psIndicator [string range $midNum 1 1]

			set numPS 2

			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 7"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "FAN[A-Z0-9: ]+"} { "Error" }]
			regexp {0:([A-Z]+)} $out f1 f2
			if { [ string equal "$f2" "NORMAL"] } {
				set fanaStatus "Normal"
			} elseif { [ string equal "$f2" "FAST"] } {
				set fanaStatus "TooFast"
			} elseif { [ string equal "$f2" "SLOW"] } {
				set fanaStatus "TooSlow"
			} elseif { [ string equal "$f2" "NOTPRESENT"] } {
				set fanaStatus "NotPresent"
			} elseif { [ string equal "$f2" "NOTAVAIL"] } {
				set fanaStatus "NotAvail"
			} else {
				set fanaStatus "Unknown"
			}
			regexp {1:([A-Z]+)} $out f1 f2
			if { [ string equal "$f2" "NORMAL"] } {
				set fanbStatus "Normal"
			} elseif { [ string equal "$f2" "FAST"] } {
				set fanbStatus "TooFast"
			} elseif { [ string equal "$f2" "SLOW"] } {
				set fanbStatus "TooSlow"
			} elseif { [ string equal "$f2" "NOTPRESENT"] } {
				set fanbStatus "NotPresent"
			} elseif { [ string equal "$f2" "NOTAVAIL"] } {
				set fanbStatus "NotAvail"
			} else {
				set fanbStatus "Unknown"
			}
			regexp {2:([A-Z]+)} $out f1 f2
			if { [ string equal "$f2" "NORMAL"] } {
				set fancStatus "Normal"
			} elseif { [ string equal "$f2" "FAST"] } {
				set fancStatus "TooFast"
			} elseif { [ string equal "$f2" "SLOW"] } {
				set fancStatus "TooSlow"
			} elseif { [ string equal "$f2" "NOTPRESENT"] } {
				set fancStatus "NotPresent"
			} elseif { [ string equal "$f2" "NOTAVAIL"] } {
				set fancStatus "NotAvail"
			} else {
				set fancStatus "Unknown"
			}
			regexp {3:([A-Z]+)} $out f1 f2
			if { [ string equal "$f2" "NORMAL"] } {
				set fandStatus "Normal"
			} elseif { [ string equal "$f2" "FAST"] } {
				set fandStatus "TooFast"
			} elseif { [ string equal "$f2" "SLOW"] } {
				set fandStatus "TooSlow"
			} elseif { [ string equal "$f2" "NOTPRESENT"] } {
				set fandStatus "NotPresent"
			} elseif { [ string equal "$f2" "NOTAVAIL"] } {
				set fandStatus "NotAvail"
			} else {
				set fandStatus "Unknown"
			}
			regexp {4:([A-Z]+)} $out f1 f2
			if { [ string equal "$f2" "NORMAL"] } {
				set faneStatus "Normal"
			} elseif { [ string equal "$f2" "FAST"] } {
				set faneStatus "TooFast"
			} elseif { [ string equal "$f2" "SLOW"] } {
				set faneStatus "TooSlow"
			} elseif { [ string equal "$f2" "NOTPRESENT"] } {
				set faneStatus "NotPresent"
			} elseif { [ string equal "$f2" "NOTAVAIL"] } {
				set faneStatus "NotAvail"
			} else {
				set faneStatus "Unknown"
			}
			regexp {5:([A-Z]+)} $out f1 f2
			if { [ string equal "$f2" "NORMAL"] } {
				set fanfStatus "Normal"
			} elseif { [ string equal "$f2" "FAST"] } {
				set fanfStatus "TooFast"
			} elseif { [ string equal "$f2" "SLOW"] } {
				set fanfStatus "TooSlow"
			} elseif { [ string equal "$f2" "NOTPRESENT"] } {
				set fanfStatus "NotPresent"
			} elseif { [ string equal "$f2" "NOTAVAIL"] } {
				set fanfStatus "NotAvail"
			} else {
				set fanfStatus "Unknown"
			}
			if { ! [ string equal "$fanaStatus/$fanbStatus/$fancStatus/$fandStatus/$faneStatus/$fanfStatus" "Normal/Normal/Normal/Normal/Normal/Normal" ] } {
				append_punchlist "$ibnode" "Fan: $fanaStatus/$fanbStatus/$fancStatus/$fandStatus/$faneStatus/$fanfStatus"
			}
			set fanStatus "$fanaStatus/$fanbStatus/$fancStatus/$fandStatus/$faneStatus/$fanfStatus"
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}

		if { [ string equal "$brand" "OPA"] } {
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 6"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "SENSOR[A-Z_0-9/_: ]+" } { "Error" }]
			regexp {LTC2974: ([NA0-9\/C]+)} $out f1 f2
			if { [ string equal "N/A" "$f2" ] } {
				append_punchlist "$ibnode" "LTC2974: Temperature Not Available"
				set tempaStatus "LTC2974:$f2"
			} else {
				set tempaStatus "LTC2974:$f2"
			}
			regexp {MAX QSFP: ([NA0-9\/C]+)} $out f1 f2
			if { [ string equal "N/A" "$f2" ] } {
				set tempbStatus "MAX_QSFP:$f2"
				append_punchlist "$ibnode" "MAX_QSFP: Temperature Not Available"
			} else {
				set tempbStatus "MAX_QSFP:$f2"
			}
			regexp {PRR ASIC: ([NA0-9\/C]+)} $out f1 f2
			if { [ string equal "N/A" "$f2" ] } {
				set tempcStatus "PRR_ASIC:$f2"
				append_punchlist "$ibnode" "PRR_ASIC: Temperature Not Available"
			} else {
				set tempcStatus "PRR_ASIC:$f2"
			}

			set tempStatus "$tempaStatus/$tempbStatus/$tempcStatus"

		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}

        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			if { "$numPS" == "2" } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 8 -i 1"
				set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "PS 1: [A-Z\/ ]+" } { "Error" }]
				regexp {([PS 1:]+) ([A-Z\/ ]+)} $out p1 p2 p3

				if { ! [ string equal "$p3" "ONLINE" ] && 
				     ! [ string equal "$p3" "OFFLINE" ] &&
				     ! [ string equal "$p3" "NOT PRESENT" ] &&
				     ! [ string equal "$p3" "N/A" ] &&
				     ! [ string equal "$p3" "INVALID" ] } {
					set ps1Status "ERROR"
				} else {
					set ps1Status "$p3"
				}
			} else {
				set ps1Status "ERROR"
			}
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 8 -i 2"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "PS 2: [A-Z\/  ]+" } { "Error" }]
			regexp {([PS 2:]+) ([A-Z\/ ]+)} $out p1 p2 p3
			if { ! [ string equal "$p3" "ONLINE" ] &&
			     ! [ string equal "$p3" "OFFLINE" ] &&
			     ! [ string equal "$p3" "NOT PRESENT" ] &&
			     ! [ string equal "$p3" "N/A" ] &&
			     ! [ string equal "$p3" "INVALID" ] } {
				set ps2Status "ERROR"
			} else {
				set ps2Status "$p3"
			}
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}

		# report the results
		show_message ""
		if { [ string equal "$brand" "OPA"] } {
#			show_message "$ibnode:
#    F/W ver:$fwversion  H/W ver:$hwversion  H/W pt num:$partnumber  Capability:$capability  Fan status:$fanStatus  PS1 Status:$ps1Status  PS2 Status:$ps2Status"
			if { [ string equal "$ps2Status" "INVALID" ] } {
				show_message "$ibnode:
    F/W ver:$fwversion  H/W ver:$hwversion  H/W pt num:$partnumber  Fan status:$fanStatus  PS1 Status:$ps1Status  Temperature status:$tempStatus"
				set out_msg "F/W ver:$fwversion
H/W ver:$hwversion
H/W pt num:$partnumber
Capability:$capability
Fan status:$fanStatus
PS1 Status:$ps1Status
Temperature status:$tempStatus"
			} elseif { [ string equal "$ps1Status" "INVALID" ] } {
				show_message "$ibnode:
    F/W ver:$fwversion  H/W ver:$hwversion  H/W pt num:$partnumber  Fan status:$fanStatus  PS2 Status:$ps2Status Temperature status:$tempStatus"
				set out_msg "F/W ver:$fwversion
H/W ver:$hwversion
H/W pt num:$partnumber
Capability:$capability
Fan status:$fanStatus
PS2 Status:$ps2Status
Temperature status:$tempStatus"
			} else {
				show_message "$ibnode:
    F/W ver:$fwversion  H/W ver:$hwversion  H/W pt num:$partnumber  Fan status:$fanStatus  PS1 Status:$ps1Status  PS2 Status:$ps2Status Temperature status:$tempStatus"
				set out_msg "F/W ver:$fwversion
H/W ver:$hwversion
H/W pt num:$partnumber
Capability:$capability
Fan status:$fanStatus
PS1 Status:$ps1Status
PS2 Status:$ps2Status
Temperature status:$tempStatus"
			}
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		local_sh_exit

		return "$out_msg"
}

proc get_switch_hwvpd { ibnode } {
##
## get_switch_hwvpd
## -------------------
## execute a test case gathering switch hwvpd from $ibnode
##
## Usage:
##	get_switch_hwvpd ibnode
## Arguments:
##	ibnode - ib node to get switch hwvpd
## Returns:
##	nothing
## Additional Information:
##	
		global env

		set toolsdir /usr/lib/opa/tools

		local_sh

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
		set brand [get_switch_brand "$ibnode"]
        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 4"
		} else {
			append_punchlist "$ibnode" "Not an OPA series device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "VPD \"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]+\",\"[[:print:]]+\",\"[[:print:]]*\",\"[[:print:]]*\",\"[[:print:]]*\"" } { "Error" }]
		regexp {([VPD]+) "([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)","([[:print:]]*)"} $out p1 p2 serialnumber partnumber model hwversion mfgname proddesc mfgid date time
		local_sh_exit

		# report the results
                show_message " \n
    $ibnode: H/W VPD serial number: $serialnumber
    $ibnode: H/W VPD part number  : $partnumber
    $ibnode: H/W VPD model        : $model
    $ibnode: H/W VPD h/w version  : $hwversion
    $ibnode: H/W VPD manufacturer : $mfgname
    $ibnode: H/W VPD prod desc    : $proddesc
    $ibnode: H/W VPD mfg id       : $mfgid
    $ibnode: H/W VPD mfg date     : $date
    $ibnode: H/W VPD mfg time     : $time"

}

proc get_switch_ping { ibnode { hfi_port ""} { report "1" } { ignore_pass "0" } } {
##
## get_switch_ping
## -------------------
## execute a test case gathering switch ping from $ibnode
##
## Usage:
##	get_switch_ping ibnode [hfi_port] [report]
## Arguments:
##	ibnode - ib node to ping
##	hfi_port - hfi:port on local system to use to access the ibnode
##	report - if "1", output presence, otherwise be silent
## Returns:
##	presence string - "is" or "not"
## Additional Information:
##	
		global env

		set toolsdir /usr/lib/opa/tools

		local_sh

		set out ""
		set node_guid ""
		set presence "not"

		if { [ string equal "$hfi_port" "" ] } {
			set hfi_port [ resolve_ibnode $ibnode ]
		}
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
        # use verbose option so we have a predictable output to expect
		set node_guid [ strip_nodename_from_guid "$trimmed_ibnode" ]
		set sa_hfi_port_args [ regsub -- "-o" "$hfi_port_args" "-p" ]
		send_unix_cmd "opasaquery $sa_hfi_port_args -n $node_guid"
		if { [ catch { expect_progress 60 {[\r\n]} { "LID" "SystemImageGuid" } { "No Records Returned" "Failed:" } } res ] != 0 } {
			set presence "not"
			log_message "$ibnode: unit is not present"
		} else {
			set brand [get_switch_brand "$ibnode"]
			if { [ string equal "$brand" "OPA"] } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswping -t $trimmed_ibnode $hfi_port_args"
			} else {
				append_punchlist "$ibnode" "Not an Intel OPA device"
				fail_test "$ibnode: Not an Intel OPA device"
			}
			if { [ catch { expect_progress 60 {[\r\n]} { "is present" } { "No Path Records Returned" "Error" } } res ] != 0 } {
				set present not
			} else {
				set present is
			}
			if { [ string equal "$present" "is"] } {
				set presence "is"
				if { [ string equal "$report" "1"] } {
					log_message "$ibnode: unit is present"
					show_message ""
					show_message "$ibnode: unit is present"
				}
			}
		}
		local_sh_exit

		return "$presence"
}

proc get_switch_fwverify { ibnode } {
##
## get_switch_fwverify
## -------------------
## execute a test case verifying f/w on $ibnode
##
## Usage:
##	get_switch_fwverify ibnode
## Arguments:
##	ibnode - ib node to verify f/w
## Returns:
##	nothing
## Additional Information:
##	
		global env

		set toolsdir /usr/lib/opa/tools

		local_sh

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } {
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswfwverify -t $trimmed_ibnode $hfi_port_args -q"
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		set out [expect_list_with_punchlist "$ibnode" "Unable to verify FW" 120 { "[A-Za-z]+ primary image" } { "Error" }]
		regexp {([A-Za-z]+)} $out pValidity

		set present "is"

		if { [ string equal "$present" "not"] } {
		#	log_message "$ibnode - no failsafe eeproms"
			set fValidity "N/A"
		} else {
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswfwverify -t $trimmed_ibnode $hfi_port_args -q -F"
			set out [expect_list_with_punchlist "$ibnode" "Unable to verify FW" 120 { "[A-Za-z]+ secondary image" } { "Error" }]
			regexp {([A-Za-z]+)} $out fValidity

			if { [ string equal "$brand" "OPA"] } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 2"
				set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 120 { "from [A-Za-z]+" } { "Error" }]
				regexp {(from) ([A-Za-z]+)} $out from f which
				log_message "$ibnode - switch has booted from $which image"
			}
		}
		show_message ""
		
		show_message "$ibnode - bootable image: $pValidity   failsafe image: $fValidity   booted from: $which"
		local_sh_exit

		if { ! ( [ string equal "$pValidity" "valid" ] || [ string equal "$fValidity" "N/A" ] ) ||
			! ( [ string equal "$pValidity" "valid" ] || [ string equal "$fValidity" "N/A" ] ) } {
			append_punchlist "$ibnode" "Corrupted FW Image: primary: $pValidity failsafe: $fValidity"
			fail_test "$ibnode: Corrupted FW Image: primary: $pValidity failsafe: $fValidity"
		}
}

proc get_switch_capture { ibnode upload_file } {
##
## get_switch_capture
## -------------------
## execute a test case gathering switch capture from $ibnode to $upload_file
##
## Usage:
##	get_switch_capture ibnode upload_file
## Arguments:
##	ibnode - ib node to get switch capture
##	upload_file - file to save capture to
## Returns:
##	nothing
## Additional Information:
##	
		global env

		set toolsdir /usr/lib/opa/tools

		local_sh

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
		set node_guid [ strip_nodename_from_guid "$trimmed_ibnode" ]
		set brand [get_switch_brand "$ibnode"]
        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			unix_cmd 60 0 "mkdir -p [ exec dirname $upload_file ]"
			# use -v so log is easier to analyze and debug failures
			# TODO: This needs to be updated with whatever the new capture file is
			send_unix_cmd "$toolsdir/xedge_capture -v -t $node_guid $hfi_port_args $upload_file"
			check_exit_status 60 0
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		local_sh_exit
}

proc test_case_i2c_extmgd_eeprom { operation ibnode fwspeed hwversion { args {}} {norecords 0} } {
##
## test_case_i2c_extmgd_eeprom
## ---------------------------
## test case to dump or upgrade the firmware image of externally managed switch
## nodes.
##
## Usage:
##	test_case_i2c_extmgd_eeprom operation ibnode [args]
## Arguments:
##	operation - dump or upgrade operation
##	ibnode - IB switch node
##	args - parameters specific to the operation
## Returns:
##	0 -> success
##	-code error on failure
## Additional Information:
##	The global timeout is changed by this routine
##

	global env

	# TBD - should separate dump and upgrade into different functions
	# fwfile, file version and action should be args of this function instead
	# of using globals, that way caller can do looping in TCL later
	if { [ string equal "$operation" "upgrade"] } {
		set info "
Firmware package File: $env(CFG_FWFILE)
Speed: $fwspeed
Firmware Version: $env(CFG_FWRELEASEVERSIONINFO)
Action: $env(CFG_FWACTION)"
	} else {
		set info ""
	}
    test_case "$ibnode.i2c.extmgd.eeprom" "$operation firmware of switch $ibnode" "Access EEPROM of switch node $ibnode$info
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar operation operation
        upvar ibnode ibnode
        upvar fwspeed fwspeed
        upvar hwversion hwversion
        upvar args args
        upvar norecords norecords


		set fw_override $env(CFG_FWOVERRIDE)

		local_sh
		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
		local_sh_exit

		set toolsdir /usr/lib/opa/tools

		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } {
			if { ! [ string equal "$env(CFG_SWITCH_DEVICE)" "OPA"] } {
				show_message ""
				skip_case "Device type of firmware -$env(CFG_SWITCH_DEVICE)- does not match switch\n"
			}
			if { [ string equal "$operation" "upgrade"] } {
				# retrieve version and asic version of target
				local_sh
				send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 3"
				set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "FW Version is [0-9.]+" } { "Error" }]
				regexp {([0-9.]+)} $out fwversion
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 9"
				set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 60 { "ASIC Version: [V0-9]+" } { "Error" }]
				regexp {([ASIC Version:]+) ([V0-9]+)} $out p1 p2 asicversion
				if { ! [string match "*$asicversion*" "$hwversion"] } {
					show_message ""
					skip_case "Switch capability of -$asicversion- does not support ASIC version of firmware -$hwversion-\n"
					# aborts via skip_case
				} elseif { $env(CFG_FWRELEASEVERSIONINFO) == $fwversion && $fw_override == "n" } {
					# if the password is not being changed, we will skip below
					#skip_case "Switch already has version $fwversion loaded"
					check_exit_status 60 0
					send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 2"
					set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 120 { "from [A-Za-z]+" } { "Error" }]
					regexp {(from) ([A-Za-z]+)} $out from f which
					if { [ string equal "$which" "primary"] } {
						set proceed 0
					} else {
						set proceed 1
					}
				} else { 
					set proceed 1
				}
				local_sh_exit
			} else {
				set proceed 1
			}
		}

		if { ! $proceed } {
			show_message ""
			skip_case "Switch already has version $fwversion loaded"
		}

        # use verbose option so we have a predictable output to expect
		local_sh
		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } {
			set modifyParam "-z 60 -u 10 -T 15000"
			set modifyParamCfg "-T 15000"
			set node_desc [ strip_nodeguid_from_desc "$trimmed_ibnode" ]
			set length [string length $node_desc]
			if { $length > 0 } {
				local_sh
				send_unix_cmd "$toolsdir/opaswconfigure -t $trimmed_ibnode $hfi_port_args -S -C 1 -s $node_desc"
				if { $norecords } {
					expect_list_with_punchlist "$ibnode" "Unable to configure switch" 60 { "opaswconfigure completed"} { "Error" } 
				} else {
					expect_list_with_punchlist "$ibnode" "Unable to configure switch" 300 { "opaswconfigure completed"} { "Error"} 
				}
			}
			if { [ file exists $env(CFG_FWTEMPDIR)] } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswfwconfigure -t $trimmed_ibnode $hfi_port_args $modifyParamCfg -d $env(CFG_FWTEMPDIR)"
				if { $norecords } {
					expect_list_with_punchlist "$ibnode" "Unable to configure switch" 60 { "opaswfwconfigure completed"} { "Error" } 
				} else {
					expect_list_with_punchlist "$ibnode" "Unable to configure switch" 300 { "opaswfwconfigure completed"} { "Error" } 
				}
			}
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 10"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 120 { "Session ID: [0-9]+" } { "Error" }]
			regexp {(Session ID:) ([0-9]+)} $out p1 p2 oldSessID
			scan $oldSessID "%d" oldsessionid 
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswfwupdate $hfi_port_args -q $modifyParam $args; echo DONE"
			if { $norecords } {
				expect_list_with_punchlist "$ibnode" "Unable to update FW" 60 { "opaswfwupdate completed"} { "Error" } 
			} else {
				expect_list_with_punchlist "$ibnode" "Unable to update FW" 300 { "opaswfwupdate completed"} { "Error" } 
			}
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
		local_sh_exit


		if { [ string equal "$operation" "upgrade"]
			 &&  [ string equal "$env(CFG_FWACTION)" "run"]  } {
			log_message "$ibnode has been reset ... waiting for return"
			# wait 30 secs first, then try up to 7.5 minutes at 10 sec intervals
			if { [ string equal "$brand" "OPA"] } {
				set sleeptime 18
			} else {
				set sleeptime 30
			}
			for {set i 0} {$i < 51} {incr i} {
				# wait for switch to reboot
				if { $i!=0 } {
				    log_message "Retrying: $ibnode not yet back online ... waiting for return"
				}
				sleep $sleeptime
				# first wait for local HFI port to come active - 30 seconds
				set active [verify_port_active "$ibnode" 30]
				if { $active == -1 } {
					append_punchlist "$ibnode" "Can not verify reboot - local HFI port not active"
					fail_test "$ibnode - can not verify reboot - local HFI port not active"
				}
				set presence [get_switch_ping "$ibnode" "$hfi_port" 0 "0"]
				if { [ string equal "$presence" "is"] } {
					break
				}
				set sleeptime 10
			}
			if { [ string equal "$presence" "not"] } {
				append_punchlist "$ibnode" "Failed to come back online after reboot"
				fail_test "$ibnode Failed to come back online after reboot"
			} elseif { [ string equal "$brand" "OPA"] } {
				local_sh
				send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 10"
				set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 120 { "Session ID: [0-9]+" } { "Error" }]
				regexp {(Session ID:) ([0-9]+)} $out p1 p2 sessID
				scan $sessID "%d" sessionid
				if { $sessionid > $oldsessionid } {
					append_punchlist "$ibnode" "Did not reboot properly"
					fail_test "$ibnode did not reboot properly"
				}
				local_sh_exit
			}
		}
    }
}

proc test_case_i2c_extmgd_reset { ibnode { args {}} {norecords 0} } {
##
## test_case_i2c_extmgd_reset
## ---------------------------
## test_case to reset externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_reset ibnode
## Arguments:
##	ibnode - IB switch node
##	args - parameters specific to the operation
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.reset" "reset switch $ibnode" "Reset switch node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode
        upvar args args
        upvar norecords norecords

		global env

		set toolsdir /usr/lib/opa/tools

		local_sh

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
		set brand [get_switch_brand "$ibnode"]
        # use verbose option so we have a predictable output to expect
		if { [ string equal "$brand" "OPA"] } {
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 10"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 120 { "Session ID: [0-9]+" } { "Error" }]
			regexp {(Session ID:) ([0-9]+)} $out p1 p2 oldSessID
			scan $oldSessID "%d" oldsessionid 
			check_exit_status 60 0
			send_unix_cmd "$toolsdir/opaswreset $hfi_port_args $args; echo DONE"
			if { $norecords } {
				expect_list_with_punchlist "$ibnode" "Unable to reboot switch" 60 { "opaswreset completed"} { "Error" } 
			} else {
				expect_list_with_punchlist "$ibnode" "Unable to reboot switch" 300 { "opaswreset completed"} { "Error" } 
			}
		} else {
			fail_test "$ibnode: Not an Intel OPA device"
		}


		local_sh_exit

		log_message "$ibnode has been reset ... waiting for return"
		# wait 30 secs first, then try up to 7.5 minutes at 10 sec intervals
		if { [ string equal "$brand" "OPA"] } {
			set sleeptime 18
		} else {
			set sleeptime 30
		}
		for {set i 0} {$i < 51} {incr i} {
			# wait for switch to reboot
			if { $i!= 0 } {
			    log_message "Retrying: $ibnode not yet back online ... waiting for return"
			}
			sleep $sleeptime
			# first wait for local HFI port to come active - 30 seconds
			set active [verify_port_active "$ibnode" 30]
			if { $active == -1 } {
				append_punchlist "$ibnode" "Can not verify reboot - local HFI port not active"
				fail_test "$ibnode - can not verify reboot - local HFI port not active"
			}
			set presence [get_switch_ping "$ibnode" "$hfi_port" 0 "1"]
			if { [ string equal "$presence" "is"] } {
				break
			}
			set sleeptime 10
		}

		if { [ string equal "$presence" "not"] } {
			fail_test "$ibnode Failed to come back online after reboot"
		} elseif { [ string equal "$brand" "OPA"] } {
			local_sh
			send_unix_cmd "$toolsdir/opaswquery -t $trimmed_ibnode $hfi_port_args -Q 10"
			set out [expect_list_with_punchlist "$ibnode" "Unable to query switch" 120 { "Session ID: [0-9]+" } { "Error" }]
			regexp {(Session ID:) ([0-9]+)} $out p1 p2 sessID
			scan $sessID "%d" sessionid
			if { $sessionid > $oldsessionid } {
				fail_test "$ibnode did not reboot properly"
			}
			local_sh_exit
		}
    }
}
proc test_case_i2c_extmgd_switchgetportconfig { ibnode {fd ""}} {
##
## test_case_i2c_extmgd_switchgetportconfig
## ---------------------------
## test_case to retrieve info about port configurations of externally managed switches 
##
## Usage:
##	test_case_i2c_extmgd_switchgetportconfig ibnode [fd]
## Arguments:
##	ibnode - IB switch node
##	fd - file to write config info to
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchgetportconfig" "retrieve switch $ibnode" "Retrieve port config info  $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode
        upvar fd fd

        # use verbose option so we have a predictable output to expect
		set out [ get_switch_getportconfig "$ibnode" ]
		if { ! [ string equal "$fd" "" ] } {
			puts $fd "\n$out"
		}
    }
}


proc test_case_i2c_extmgd_switchinfo { ibnode {fd ""}} {
##
## test_case_i2c_extmgd_switchinfo
## ---------------------------
## test_case to retrieve info from externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_info ibnode [fd]
## Arguments:
##	ibnode - IB switch node
##	fd - file to write config info to
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchinfo" "retrieve switch $ibnode" "Retrieve switch info node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode
        upvar fd fd

        # use verbose option so we have a predictable output to expect
		set out [get_switch_info "$ibnode"]
		if { ! [ string equal "$fd" "" ] } {
			puts $fd "\n$out"
		}
    }
}

proc test_case_i2c_extmgd_switchhwinfo { ibnode } {
##
## test_case_i2c_extmgd_switchhwinfo
## ---------------------------
## test_case to retrieve hw info from externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_hwinfo ibnode
## Arguments:
##	ibnode - IB switch node
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchhwinfo" "retrieve switch $ibnode" "Retrieve switch hwinfo node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode

        # use verbose option so we have a predictable output to expect
		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } {
			# are we going to implement this?
			puts "Function not yet implemented for Intel OPA"
		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}
    }
}

proc test_case_i2c_extmgd_switchhwvpd { ibnode } {
##
## test_case_i2c_extmgd_switchhwvpd
## ---------------------------
## test_case to retrieve hw vpd from externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_hwvpd ibnode
## Arguments:
##	ibnode - IB switch node
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchhwvpd" "retrieve switch $ibnode" "Retrieve switch hwvpd node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode

        # use verbose option so we have a predictable output to expect
		get_switch_hwvpd "$ibnode"
    }
}

proc test_case_i2c_extmgd_switchping { ibnode } {
##
## test_case_i2c_extmgd_switchping
## ---------------------------
## test_case to retrieve hw vpd from externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_ping ibnode
## Arguments:
##	ibnode - IB switch node
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchping" "ping switch $ibnode" "Ping switch node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode

		set presence [ get_switch_ping "$ibnode" "" 0 ]
		if { [ string equal "$presence" "not"] } {
			append_punchlist "$ibnode" "Not responding"
			fail_test "$ibnode Not Responding"
		} else {
			log_message "$ibnode: unit is present"
			show_message ""
			show_message "$ibnode: unit is present"
		}
    }
}

proc test_case_i2c_extmgd_switchfwverify { ibnode } {
##
## test_case_i2c_extmgd_switchfwverify
## ---------------------------
## test_case to verify firmware in externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_fwverify ibnode
## Arguments:
##	ibnode - IB switch node
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchfwverify" "retrieve switch $ibnode" "Verify firmware node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode
        upvar args args
        upvar norecords norecords

        # use verbose option so we have a predictable output to expect
		get_switch_fwverify "$ibnode"
    }
}

proc test_case_ext_mgmt_sw_config { ibnode } {

	global tools_case_status
	global env

    test_case "$ibnode.i2c.extmgd.switchconfigure" "configure switch $ibnode" "Configure node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode
        upvar args args
        upvar norecords norecords

		set toolsdir /usr/lib/opa/tools

		local_sh

		set hfi_port [ resolve_ibnode $ibnode ]
		set hfi_port_args [ get_hfi_port_args "$hfi_port" ]
		set trimmed_ibnode [ trim_opaswitch_hfi_port "$ibnode" ]
        # use verbose option so we have a predictable output to expect

		set brand [get_switch_brand "$ibnode"]
		if { [ string equal "$brand" "OPA"] } { 
			set linkWidthSelection $env(LINKWIDTH_SETTING)

			if { [string equal "$linkWidthSelection" "0"] == 0 } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswconfigure -t $trimmed_ibnode $hfi_port_args -S -C 5 -i $linkWidthSelection"
				expect_list_with_punchlist "$ibnode" "Unable to configure switch link width" 60 { "opaswconfigure completed"} { "Error" } 
			}

			set nodeDescSelection $env(NODEDESC_SETTING)

			if { [string equal "$nodeDescSelection" "0"] == 0 } {
				set node_desc [ strip_nodeguid_from_desc "$trimmed_ibnode" ]
				set length [string length $node_desc]
				if { $length > 0 } {
					local_sh
					send_unix_cmd "$toolsdir/opaswconfigure -t $trimmed_ibnode $hfi_port_args -S -C 1 -s $node_desc"
					expect_list_with_punchlist "$ibnode" "Unable to configure switch node description" 60 { "opaswconfigure completed"} { "Error" } 
				}
			}

			set FMEnabledSelection $env(FMENABLED_SETTING)

			if { [string equal "$FMEnabledSelection" "-1"] == 0 } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswconfigure -t $trimmed_ibnode $hfi_port_args -S -C 8 -i $FMEnabledSelection"
				expect_list_with_punchlist "$ibnode" "Unable to configure switch FM Enabled" 60 { "opaswconfigure completed" } { "Error" }
			}

			set linkCRCModeSelection $env(LINKCRCMODE_SETTING)

			if { [string equal "$linkCRCModeSelection" "-1"] == 0 } {
				check_exit_status 60 0
				send_unix_cmd "$toolsdir/opaswconfigure -t $trimmed_ibnode $hfi_port_args -S -C 9 -i $linkCRCModeSelection"
				expect_list_with_punchlist "$ibnode" "Unable to configure switch link CRC mode" 60 { "opaswconfigure completed" } { "Error" }
			}

		} else {
			append_punchlist "$ibnode" "Not an Intel OPA device"
			fail_test "$ibnode: Not an Intel OPA device"
		}

		local_sh_exit

	}
}

proc test_case_i2c_extmgd_switchcapture { ibnode upload_file } {
##
## test_case_i2c_extmgd_switchcapture
## ---------------------------
## test_case to retrieve capture from externally managed switch
##
## Usage:
##	test_case_i2c_extmgd_switchcapture ibnode upload_file
## Arguments:
##	ibnode - IB switch node
##	upload_file - file to upload too
## Returns:
##	None
## Additional Information:
##	must be used within a test_suite's body, performs test_case calls
##	uses case_setup and case_cleanup provided by caller
##	no item_setup nor item_cleanup used

    test_case "$ibnode.i2c.extmgd.switchcapture" "capture switch $ibnode" "Capture switch state node $ibnode
File: TestTools/extmng.exp" case_setup case_cleanup {
        upvar ibnode ibnode
        upvar upload_file upload_file

        # use verbose option so we have a predictable output to expect
		get_switch_capture "$ibnode" "$upload_file"
    }
}