sdk-debugger-openocd-infineon/scripts/target/mxs40/mxs40v2_acquire_helpers.cfg

#
# Copyright (C) <2019-2021>
#   <Cypress Semiconductor Corporation (an Infineon company)>
#
# Acquisition helpers for MXS40v2 family of microcontrollers.
#

if [info exist LOADED_[file rootname [file tail [info script]]]] return
set LOADED_[file rootname [file tail [info script]]] true

source [find target/cympn.cfg]
source [find target/mxs40/cyw20829_status_codes.cfg]

namespace eval mxs40v2 {

variable CYBOOT_ID_MASK                   0xFFF00000
variable CYBOOT_ID_FAIL                   0xBAF00000
variable CYBOOT_ID_SUCCESS                0x0D500000
variable CYAPP_ID_MASK                    0xFFF00000
variable CYAPP_ID_FAIL                    0x45000000
variable CYAPP_ID_SUCCESS                 0xF2A00000

variable ACQUIRE_TIMEOUT                  2500
variable EFUSE_BOOTROW_ADDR               0x40810180
variable EFUSE_CTRL_ADDR                  0x40810000
variable EFUSE_DEVICE_ID_ADDR             0x40810878
variable EFUSE_SI_REV_ID_ADDR             0x4081087C
variable NVIC_VTOR_ADDR                   0xE000ED08
variable RAM_BOOT_BUILD_ADDR              0x20000008
variable RAM_BOOT_STATUS_ADDR             0x20000000
variable RAM_BOOT_VERSION_ADDR            0x20000004
variable SRSS_RES_SOFT_CTL_ADDR           0x40200410
variable SRSS_RES_SOFT_CTL_RESET_MASK     0x00000001
variable SRSS_TST_DEBUG_CTL_ADDR          0x40200404
variable SRSS_TST_DEBUG_CTL_WFA_MASK      0x80000000
variable SRSS_TST_DEBUG_CTL_WFA_REQ       0x00000001
variable SRSS_TST_DEBUG_STATUS_ADDR       0x40200408
variable SRSS_TST_MODE_ADDR               0x40200400
variable SRSS_TST_MODE_MASK               0x80000000

namespace eval priv {

	variable push_count 0
	variable pushed_log_level 0

	proc push_log_settings {} {
		variable push_count
		variable pushed_log_level

		if { $push_count == 0 } {
			local_echo off
			scan [debug_level] "debug_level: %d" pushed_log_level
			debug_level -1
		}
		incr push_count
	}

	proc pop_log_settings {} {
		variable push_count
		variable pushed_log_level

		if { $push_count == 0 } {
			puts stderr "push/pop log settings mismatch"
		} else {
			incr push_count -1
		}

		if { $push_count == 0 } {
			debug_level $pushed_log_level
			local_echo on
		}
	}

	proc default_dap_ap { dap_name ap_num } {
		upvar $dap_name dap
		upvar $ap_num   ap

		set target [target current]
		set dap [expr {$dap ne {} ? $dap : [$target cget -dap]}]
		set ap  [expr {$ap  ne {} ? $ap  : [$target cget -ap-num]}]
	}

	proc read32 { dap ap address } {
		push_log_settings
		catch {
			$dap apreg $ap 0x00 0xAB000002
			$dap apreg $ap 0x04 $address
			$dap apreg $ap 0x0C
		} result options
		pop_log_settings
		return {*}$options [string trim $result]
	}

	proc write32 { dap ap address val } {
		$dap apreg $ap 0x00 0xAB000002
		$dap apreg $ap 0x04 $address
		$dap apreg $ap 0x0C $val
	}

	proc is_idle_loop { dap ap } {
		variable [namespace parent]::CYBOOT_ID_FAIL
		variable [namespace parent]::CYBOOT_ID_MASK
		variable [namespace parent]::CYBOOT_ID_SUCCESS
		variable [namespace parent]::CYBOOT_NEXT_APP_LAUNCHED
		variable [namespace parent]::CYBOOT_WFA_POLLING
		variable [namespace parent]::RAM_BOOT_STATUS_ADDR
		variable [namespace parent]::SRSS_TST_DEBUG_CTL_ADDR
		variable [namespace parent]::SRSS_TST_DEBUG_CTL_WFA_MASK
		variable [namespace parent]::SRSS_TST_DEBUG_STATUS_ADDR

		if [catch {read32 $dap $ap $SRSS_TST_DEBUG_STATUS_ADDR} mmio_status] {
			return 0
		}

		if [catch {read32 $dap $ap $SRSS_TST_DEBUG_CTL_ADDR} debug_status] {
			return 0
		}

		# CYBOOT_ID_FAIL in SRSS_TST_DEBUG_CTL_ADDR means device is CORRUPTED
		# Return BREAK status to exit outer polling loop
		if { [expr {$mmio_status & $CYBOOT_ID_MASK}] == $CYBOOT_ID_FAIL } {
			return -code break
		}

		if {$mmio_status == $CYBOOT_WFA_POLLING &&
		   [expr {$debug_status & $SRSS_TST_DEBUG_CTL_WFA_MASK}]} {
			return 1
		}

		if [catch {read32 $dap $ap $RAM_BOOT_STATUS_ADDR} ram_status] {
			return 0
		}

		if { [expr {$ram_status & $CYBOOT_ID_MASK}] == $CYBOOT_ID_FAIL    ||
			 [expr {$ram_status & $CYBOOT_ID_MASK}] == $CYBOOT_ID_SUCCESS &&
			 $ram_status != $CYBOOT_NEXT_APP_LAUNCHED } {
			return 1
		}

		# CYBOOT_NEXT_APP_LAUNCHED means we've missed listen window
		# Return BREAK status to exit outer polling loop
		if {$ram_status == $CYBOOT_NEXT_APP_LAUNCHED} {
			return -code break
		}

		return 0
	}

	proc do_reset { reset_mode dap ap } {
		variable [namespace parent]::SRSS_RES_SOFT_CTL_ADDR
		variable [namespace parent]::SRSS_RES_SOFT_CTL_RESET_MASK

		if { $reset_mode > 2 } {
			return 0
		}

		set RESET_METHODS { 0 "XRES pin" 1 "DP.CDBGRSTREQ" 2 "SRSS_RES_SOFT_CTL" }
		echo "** Reset using $RESET_METHODS($reset_mode)"

		if { $reset_mode == 0 } {
			adapter assert srst
			adapter deassert srst
		} elseif { $reset_mode == 1 } {
			catch {$dap dpreg 4 0xF4000040}
		} elseif { $reset_mode == 2 } {
			catch {write32 $dap $ap $SRSS_RES_SOFT_CTL_ADDR $SRSS_RES_SOFT_CTL_RESET_MASK}
		}

		return 1
	}

# namespace eval priv
}

#####################################################################################################################
#
#####################################################################################################################
proc wait_for_idle_loop { {dap {}} {ap {}} } {
	variable ACQUIRE_TIMEOUT

	priv::default_dap_ap dap ap

	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off
	priv::pop_log_settings

	set ret 0
	set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
	while {[clock milliseconds] < $t_end} {
		if [priv::is_idle_loop $dap $ap] {
			set ret 1
			break
		}
	}

	priv::push_log_settings
	eval poll $poll_status
	priv::pop_log_settings
	return $ret
}

#####################################################################################################################
#
#####################################################################################################################
proc is_ap_open { {dap {}} {ap {}} } {
	priv::default_dap_ap dap ap
	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off

	set ret 0
	# read location of the ROM Table to check if AP is opened
	if ![catch {
			set dbg_base [string trim [$dap apreg $ap 0xF8]]
			priv::read32 $dap $ap $dbg_base
		}] {
		set ret 1
	}

	eval poll $poll_status
	priv::pop_log_settings

	return $ret
}

#####################################################################################################################
#
#####################################################################################################################
proc wait_for_ap_open { {dap {}} {ap {}} } {
	variable ACQUIRE_TIMEOUT

	priv::default_dap_ap dap ap

	set ret 0
	set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
	while {[clock milliseconds] < $t_end} {
		if {[is_ap_open $dap $ap]} {
			set ret 1
			break
		}
	}

	return $ret
}

#####################################################################################################################
#
#####################################################################################################################
proc decode_lcs { bootrow } {
	if { $bootrow == 0x00 } { return "VIRGIN" }
	if { $bootrow == 0x29 } { return "SORT" }
	if { [expr {$bootrow & 0x3F}] != 0x29 } { return "CORRUPTED" }

	set tmp $bootrow
	set tmp [expr {(($tmp >> 1 ) ^ $tmp ) & 0x00005540}]
	if { $tmp != 0 }  { return "CORRUPTED" }

	set bootrow [expr {$bootrow & 0x0000FFC0}]

	set lcs_table {
		{ "PROVISIONED"        0x00C0 }
		{ "NORMAL"             0xC000 }
		{ "NORMAL_NO_SECURE"   0xCC00 }
		{ "NORMAL_PROVISIONED" 0xC0C0 }
		{ "SECURE"             0xC3C0 }
		{ "RMA"                0xF000 }
		{ "RMA"                0xFC00 }
		{ "RMA"                0xF3C0 }
	}

	foreach lcs $lcs_table {
		if { $bootrow == [lindex $lcs 1] } { return [lindex $lcs 0] }
	}

	return "CORRUPTED"
}

#####################################################################################################################
#
#####################################################################################################################
proc decode_boot_status { status } {
	foreach val $::mxs40v2::cyw20829_boot_status_codes {
		if { $status == [lindex $val 1] } { return [lindex $val 0] }
	}

	foreach val $::mxs40v2::cyw20829_app_status_codes {
		if { $status == [lindex $val 1] } { return [lindex $val 0] }
	}

	return "None/Unknown ([format 0x%08X $status])"
}

#####################################################################################################################
#
#####################################################################################################################
proc display_chip_info { chipname {force no} {dap {}} {ap {}} } {
# Run info command inly once for each particular chip, unless forced
	global ${chipname}::info_runned
	if { [info exists ${chipname}::info_runned] && $force != "force" } return
	set ${chipname}::info_runned 1

	variable CYBOOT_ID_FAIL
	variable CYBOOT_ID_MASK
	variable CYBOOT_SERVICE_APP_NOT_LAUNCHED
	variable EFUSE_BOOTROW_ADDR
	variable EFUSE_CTRL_ADDR
	variable EFUSE_DEVICE_ID_ADDR
	variable EFUSE_SI_REV_ID_ADDR
	variable RAM_BOOT_BUILD_ADDR
	variable RAM_BOOT_STATUS_ADDR
	variable RAM_BOOT_VERSION_ADDR
	variable SRSS_TST_DEBUG_STATUS_ADDR

	priv::default_dap_ap dap ap
	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off

	set efuse_ctl 0
	catch {priv::read32 $dap $ap $EFUSE_CTRL_ADDR} efuse_ctl
	catch {priv::write32 $dap $ap $EFUSE_CTRL_ADDR [expr {$efuse_ctl | 0x80000000}]}

	echo "***************************************"
	set display_str "** "

	if ![catch {priv::read32 $dap $ap $EFUSE_DEVICE_ID_ADDR} dev_id] {
		set siid [format "%04X" [expr {$dev_id & 0xFFFF}]]
		set family [format "%03X" [expr {($dev_id >> 16) & 0xFFF}]]
		append display_str "Silicon: 0x$siid, Family: 0x$family"
	}

	if ![catch {priv::read32 $dap $ap $EFUSE_SI_REV_ID_ADDR} rev_id] {
		set revision [format "%02X" [expr {$rev_id & 0xFF}]]
		set rev_major "0x0[string index $revision 0]"
		set rev_major_str [expr {$rev_major == 0 ? "?" : [format %c [expr {$rev_major + 0x40}]]}]
		set rev_minor "0x0[string index $revision 1]"
		set rev_minor_str [expr {$rev_minor == 0 ? "?" : [expr {$rev_minor - 1} ]}]
		if {$display_str ne "** "} { append display_str ", " }
		append display_str "Rev.: 0x$revision (${rev_major_str}${rev_minor_str})"
	}

	if {$display_str ne "** "} {
		echo $display_str
	}

	if { [info exists siid] && [dict exists $::MPN $siid] } {
		echo "** Detected Device: [lindex $::MPN($siid) 0]"
	} else {
		echo "** Device is not present in the UDD"
	}

	set lcs {}
	if ![catch {priv::read32 $dap $ap $EFUSE_BOOTROW_ADDR} bootrow] {
		set lcs [decode_lcs $bootrow]
		echo "** Life Cycle  : $lcs"
	}

	set is_corrupted 0
	if ![catch {priv::read32 $dap $ap $SRSS_TST_DEBUG_STATUS_ADDR} mmio_status] {
		if { [expr {$mmio_status & $CYBOOT_ID_MASK}] == $CYBOOT_ID_FAIL } {
			echo "** Boot Status : [decode_boot_status $mmio_status]"
			echo "** Reached CORRUPTED branch"
			set is_corrupted 1
		}
	}

	if { !$is_corrupted } {
		if { ![catch {priv::read32 $dap $ap $RAM_BOOT_VERSION_ADDR} boot_version] &&
			 ![catch {priv::read32 $dap $ap $RAM_BOOT_BUILD_ADDR} boot_build] } {
			set major [expr {($boot_version & 0xFF0000) >> 16}]
			set minor [expr {($boot_version & 0x00FF00) >> 8}]
			set patch [expr {$boot_version & 0x0000FF}]
			echo [format "** Boot version: %d.%d.%d.%d" $major $minor $patch $boot_build]
		}

		if { ![catch {priv::read32 $dap $ap $RAM_BOOT_STATUS_ADDR} boot_status] } {
			echo "** Boot Status : [decode_boot_status $boot_status]"
			if { [expr {$boot_status & $CYBOOT_ID_MASK}] == $CYBOOT_ID_FAIL} {
				echo "** Reached DEAD branch"
			}
		}
	}

	echo "***************************************"

	if { $lcs eq "NORMAL" } {
		puts stderr "**** WARNING ******************************************************************"
		puts stderr "* The detected device is in NORMAL Life Cycle. Programmed application"
		puts stderr "* will not start until the device is moved to NORMAL_SECURE or NORMAL_NO_SECURE"
		puts stderr "* state. Please refer to the README.md in the device BSP for more information."
		puts stderr "*******************************************************************************"
	}

	catch {priv::write32 $dap $ap $EFUSE_CTRL_ADDR $efuse_ctl}

	eval poll $poll_status
	priv::pop_log_settings
}

#####################################################################################################################
#
#####################################################################################################################
proc acquire_wfa { {request {}} {dap {}} {ap {}} } {
	variable SRSS_RES_SOFT_CTL_ADDR
	variable SRSS_RES_SOFT_CTL_RESET_MASK
	variable SRSS_TST_DEBUG_CTL_ADDR
	variable SRSS_TST_DEBUG_CTL_WFA_MASK
	variable SRSS_TST_DEBUG_CTL_WFA_REQ

	priv::default_dap_ap dap ap
	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off
	priv::pop_log_settings

	set request [expr {$request ne {} ? $request : $SRSS_TST_DEBUG_CTL_WFA_REQ}]

	if [expr {[priv::read32 $dap $ap $SRSS_TST_DEBUG_CTL_ADDR] & $SRSS_TST_DEBUG_CTL_WFA_MASK}] {
		catch {
			priv::write32 $dap $ap $SRSS_TST_DEBUG_CTL_ADDR $SRSS_TST_DEBUG_CTL_WFA_MASK
			priv::write32 $dap $ap $SRSS_RES_SOFT_CTL_ADDR $SRSS_RES_SOFT_CTL_RESET_MASK
		}
	}

	if ![wait_for_ap_open $dap $ap] {
		puts stderr "** Timed out waiting for AP #$ap to open!"
	}

	catch {
		priv::write32 $dap $ap $SRSS_TST_DEBUG_CTL_ADDR $request
		priv::write32 $dap $ap $SRSS_RES_SOFT_CTL_ADDR $SRSS_RES_SOFT_CTL_RESET_MASK
	}

	set result [wait_for_idle_loop $dap $ap]

	if {$result} {
		echo "** Target acquired in FWA mode (req: [format 0x%02X $request])"
	} else {
		puts stderr "** Acquisition in WFA mode FAILED!"
	}

	priv::push_log_settings
	eval poll $poll_status
	priv::pop_log_settings
	return $result
}

#####################################################################################################################
#
#####################################################################################################################
proc launch_service_app { {dap {}} {ap {}} } {
	variable ACQUIRE_TIMEOUT
	variable CYAPP_APP_RUNNING
	variable CYAPP_ID_FAIL
	variable CYAPP_ID_MASK
	variable CYAPP_SUCCESS
	variable CYBOOT_SERVICE_APP_LAUNCHED
	variable CYBOOT_SERVICE_APP_NOT_LAUNCHED
	variable SRSS_TST_DEBUG_CTL_ADDR
	variable SRSS_TST_DEBUG_STATUS_ADDR

	priv::default_dap_ap dap ap
	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off
	priv::pop_log_settings

	catch {priv::write32 $dap $ap $SRSS_TST_DEBUG_CTL_ADDR 0}

	set result 0
	set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
	while {[clock milliseconds] < $t_end} {
		if [catch {priv::read32 $dap $ap $SRSS_TST_DEBUG_STATUS_ADDR} mmio_status] continue

		if {$mmio_status == $CYAPP_APP_RUNNING} {
			echo "** Service application launched!"
			set result 1
			break
		}

		if {$mmio_status == $CYBOOT_SERVICE_APP_NOT_LAUNCHED} {
			puts stderr "** Service application was not launched by the Boot!"
			set result 0
			break
		}
	}

	if {$result} {
		echo "** Waiting for service application to complete..."

		set result 0
		set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
		while {[clock milliseconds] < $t_end} {
			if [catch {priv::read32 $dap $ap $SRSS_TST_DEBUG_STATUS_ADDR} mmio_status] continue
			if {$mmio_status == $CYAPP_APP_RUNNING} continue

			if {$mmio_status == $CYAPP_SUCCESS} {
				echo "** Service application completed successfully!"
				set result 1
				break
			}

			if {[expr {$mmio_status & $CYAPP_ID_MASK}] == $CYAPP_ID_FAIL} {
				puts stderr "** Service application failed! Status: [decode_boot_status $mmio_status]"
				set result 0
				break
			}
		}
	}

	priv::push_log_settings
	eval poll $poll_status
	priv::pop_log_settings

	return $result
}

if { [adapter name] eq "kitprog3" && ![using_jtag]} {
	# Configure KitProg3/MiniProg4 parameters for CYW20829 device acquisition:
	#   target_type == 4 (CY20829); mode == 0 (Reset); attempts == 2
	kitprog3 acquire_config off 4 0 2
}

#####################################################################################################################
#
#####################################################################################################################
proc toggle_xres { {dap {}} {ap {}} } {
	variable ACQUIRE_TIMEOUT
	variable SRSS_TST_MODE_ADDR
	variable SRSS_TST_MODE_MASK

	priv::default_dap_ap dap ap
	priv::push_log_settings
	set reset_cfg [reset_config]
	reset_config srst_only
	scan [poll status] "background polling: %s" poll_status
	poll off

	set reset_mode 0
	while { 1 } {
		set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
		while {[clock milliseconds] < $t_end} {
			if ![catch {priv::write32 $dap $ap $SRSS_TST_MODE_ADDR $SRSS_TST_MODE_MASK}] break
		}

		if { [priv::do_reset $reset_mode $dap $ap] == 0 } {
			puts stderr "** Failed to reset the device"
			break
		}

		set tst_mode 0xDEADBEEF
		while {[clock milliseconds] < $t_end} {
			if ![catch {set tst_mode [priv::read32 $dap $ap $SRSS_TST_MODE_ADDR]}] break
		}

		if { $tst_mode == 0 } break

		incr reset_mode
	}

	eval poll $poll_status
	eval [concat reset_config $reset_cfg]
	priv::pop_log_settings
}

#####################################################################################################################
#
#####################################################################################################################
proc acquire_xres { {dap {}} {ap {}} } {
	variable ACQUIRE_TIMEOUT
	variable SRSS_TST_MODE_ADDR
	variable SRSS_TST_MODE_MASK
	variable SRSS_RES_SOFT_CTL_ADDR
	variable SRSS_RES_SOFT_CTL_RESET_MASK

	priv::default_dap_ap dap ap
	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off
	priv::pop_log_settings

	local_echo off
	scan [adapter srst delay] "adapter srst delay: %d" srst_delay
	set reset_cfg [reset_config]

	adapter srst delay 0
	reset_config srst_only

	set result 0
	if { [adapter name] eq "kitprog3" && ![using_jtag]} {
		kitprog3 acquire_psoc
		set result [wait_for_idle_loop $dap $ap]
	}

	if {$result == 0} {
		for {set i 0} {$i < 3} {incr i} {
			set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
			priv::do_reset $i $dap $ap
			while {[clock milliseconds] < $t_end} {
				if ![catch {priv::write32 $dap $ap $SRSS_TST_MODE_ADDR $SRSS_TST_MODE_MASK}] break
			}

			set result [wait_for_idle_loop $dap $ap]
			if {$result} break
		}
	}

	local_echo off
	adapter srst delay $srst_delay
	eval [concat reset_config $reset_cfg]
	local_echo on

	if {$result} {
		echo "** Target acquired in Test Mode"
	} else {
		puts stderr "** Acquisition in Test Mode FAILED!"
	}

	priv::push_log_settings
	eval poll $poll_status
	priv::pop_log_settings
	return $result
}

#####################################################################################################################
#
#####################################################################################################################
proc reset_wait_halt { target } {
	variable ACQUIRE_TIMEOUT
	variable CYBOOT_IDLE_BRANCH_REACHED
	variable CYBOOT_ID_FAIL
	variable CYBOOT_ID_MASK
	variable CYBOOT_NEXT_APP_LAUNCHED
	variable RAM_BOOT_STATUS_ADDR

	set app_launched 0
	set t_end [expr {[clock milliseconds] + $ACQUIRE_TIMEOUT}]
	while {[clock milliseconds] < $t_end} {
		$target arp_examine
		$target arp_poll
		$target arp_poll
		set boot_status [mrw $RAM_BOOT_STATUS_ADDR]
		if [expr {($boot_status & $CYBOOT_ID_MASK) == $CYBOOT_ID_FAIL}] break
		if {$boot_status == $CYBOOT_IDLE_BRANCH_REACHED} break
		if {$boot_status == $CYBOOT_NEXT_APP_LAUNCHED} {
			set app_launched 1
			break
		}
	}

	set ret_val 1
	if {$app_launched} {
		if [catch {$target arp_waitstate halted 1000}] {
			set ret_val 0
		}
	} else {
		puts stderr "** Application was not launched, boot status: [decode_boot_status $boot_status]"
		$target arp_halt
		$target arp_waitstate halted 1000
	}

	return $ret_val
}

#####################################################################################################################
#
#####################################################################################################################
proc reset_halt_breakpoint { target use_certificate } {
	variable NVIC_VTOR_ADDR

	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off
	priv::pop_log_settings

	set vtbl_addr [mrw $NVIC_VTOR_ADDR]
	if { !($vtbl_addr >= 0x20000000 && $vtbl_addr < 0x20020000) &&
		 !($vtbl_addr >= 0x04000000 && $vtbl_addr < 0x04020000) &&
		 !($vtbl_addr >= 0x60000000 && $vtbl_addr < 0x68000000) &&
		 !($vtbl_addr >= 0x08000000 && $vtbl_addr < 0x10000000) } {
		puts stderr "** Vector Table address invalid ([format 0x%08X $vtbl_addr]), using predefined address (0x20004000)"
		set vtbl_addr 0x20004000
	}

	set entry_addr [mrw [expr {$vtbl_addr + 4}]]
	if { !($entry_addr >= 0x20000000 && $entry_addr < 0x20020000) &&
		 !($entry_addr >= 0x04000000 && $entry_addr < 0x04020000) &&
		 !($entry_addr >= 0x60000000 && $entry_addr < 0x68000000) &&
		 !($entry_addr >= 0x08000000 && $entry_addr < 0x10000000) } {
		puts stderr "** Entry Point address invalid ([format 0x%08X $entry_addr])"
		eval poll $poll_status
		return
	}

	echo "** Entry Point found at ([format 0x%08X $entry_addr])"

	priv::push_log_settings
	bp $entry_addr 2 hw

	if {$use_certificate} {
		send_certificate
	} else {
		catch {mww 0xE000ED0C 0x05FA0004}
	}

	priv::pop_log_settings
	wait_for_ap_open
	set ret_val [reset_wait_halt $target]

	# Remove all breakpoints
	rbp all
	eval poll $poll_status

	return $ret_val
}

#####################################################################################################################
#
#####################################################################################################################
proc reset_halt_vector_catch { target use_certificate } {
	priv::push_log_settings
	scan [poll status] "background polling: %s" poll_status
	poll off

	# Setup VectorCatch
	set prev_demcr [mrw 0xE000EDFC]
	mww 0xE000EDFC 0x01000001

	if {$use_certificate} {
		send_certificate
	} else {
		catch {mww 0xE000ED0C 0x05FA0004}
	}

	priv::pop_log_settings
	wait_for_ap_open
	set ret_val [reset_wait_halt $target]

	# Clear VectorCatch
	mww 0xE000EDFC $prev_demcr

	eval poll $poll_status
	return $ret_val
}

#####################################################################################################################
#
#####################################################################################################################
proc reset_halt { target {use_certificate 0}} {
	if ![reset_halt_vector_catch $target $use_certificate] {
		puts stderr "** VectorCatch acquisition failed, falling back to BKPT method"
		if ![reset_halt_breakpoint $target $use_certificate] {
			puts stderr "** BKPT acquisition also failed, giving up"
		}
	}
}

# namespace eval mxs40v2
}

#####################################################################################################################
#
#####################################################################################################################
proc provision_no_secure {service_app params {service_app_addr 0x20004000} {params_addr 0x2000D000}} {
	if {[command mode] == "exec"} {
		puts stderr "** The 'provision_no_secure' can only be called before 'init'"
		return
	}

	set tgt [target current]
	set sep [string last "." $tgt]
	set cm33_target [string range $tgt 0 [expr {$sep - 1}]].cm33
	set sysap_target [string range $tgt 0 [expr {$sep - 1}]].sysap

	$cm33_target configure -defer-examine
	targets $sysap_target

	init
	mxs40v2::acquire_xres

	set lcs [mxs40v2::decode_lcs [mrw $::mxs40v2::EFUSE_BOOTROW_ADDR]]
	echo "** Current Life Cycle: $lcs"

	if {$lcs ne "NORMAL"} {
		puts stderr "** Transition to NORMAL_NO_SECURE can only be done when device is in NORMAL Life Cycle"
		return
	}

	mxs40v2::acquire_wfa 1
	load_image $service_app $service_app_addr
	load_image $params $params_addr
	mxs40v2::launch_service_app
	mxs40v2::acquire_xres

	set lcs [mxs40v2::decode_lcs [mrw $::mxs40v2::EFUSE_BOOTROW_ADDR]]
	echo "** Current Life Cycle: $lcs"
}