URL https://opencores.org/ocsvn/openmsp430/openmsp430/trunk

Subversion Repositories openmsp430

[/] [openmsp430/] [trunk/] [tools/] [lib/] [tcl-lib/] [dbg_functions.tcl] - Blame information for rev 203

Go to most recent revision | Details | Compare with Previous | View Log


#-----------------------------------------------------------------------------------------------------------
# Copyright (C) 2001 Authors
#
# This source file may be used and distributed without restriction provided
# that this copyright statement is not removed from the file and that any
# derivative work contains the original copyright notice and the associated
# disclaimer.
#
# This source file is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.
#
# This source 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 Lesser General Public
# License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this source; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
#-----------------------------------------------------------------------------------------------------------
# 
# File Name:   dbg_functions.tcl
#
# Author(s):
#             - Olivier Girard,    olgirard@gmail.com
#
#-----------------------------------------------------------------------------------------------------------
# $Rev: 172 $
# $LastChangedBy: olivier.girard $
# $LastChangedDate: 2012-12-28 00:06:56 +0100 (Fri, 28 Dec 2012) $
#-----------------------------------------------------------------------------------------------------------
#
# Description: Main utility functions for the openMSP430 serial debug
#             interface.
#
#       The following functions are implemented according to the SLAA149
#     application report from TI (Programming a Flash-Based MSP430 Using the
#     JTAG Interface):
#
#               - GetDevice       (CpuNr)
#               - ReleaseDevice   (CpuNr, Addr)
#               - ExecutePOR      (CpuNr)
#               - SetPC           (CpuNr, Addr)
#               - HaltCPU         (CpuNr)
#               - ReleaseCPU      (CpuNr)
#               - WriteMem        (CpuNr, Format,    Addr,     Data)
#               - WriteMemQuick   (CpuNr, StartAddr, DataList)
#               - ReadMem         (CpuNr, Format,    Addr)
#               - ReadMemQuick    (CpuNr, StartAddr, Length)
#               - VerifyMem       (CpuNr, StartAddr, DataList)
#
#
#       The following have been added:
#
#               - ExecutePOR_Halt (CpuNr)
#               - GetCPU_ID       (CpuNr)
#               - GetCPU_ID_SIZE  (CpuNr)
#               - VerifyCPU_ID    (CpuNr)
#               - WriteReg        (CpuNr, Addr,      Data)
#               - WriteRegAll     (CpuNr, DataList)
#               - ReadReg         (CpuNr, Addr)
#               - ReadRegAll      (CpuNr)
#               - WriteMemQuick8  (CpuNr, StartAddr, DataList)
#               - ReadMemQuick8   (CpuNr, StartAddr, Length)
#               - StepCPU         (CpuNr)
#               - EraseRAM        (CpuNr)
#               - EraseROM        (CpuNr)
#               - InitBreakUnits  (CpuNr)
#               - SetHWBreak      (CpuNr, Type, Addr,      Rd,       Wr)
#               - ClearHWBreak    (CpuNr, Type, Addr)
#               - IsHalted        (CpuNr)
#               - ClrStatus       (CpuNr)
#               - GetChipAlias    (CpuNr)
#               - GetAllowedSpeeds()
# 
#-----------------------------------------------------------------------------------------------------------
 
#==========================================================================================================#
# GLOBAL VARIABLES: OMSP_CONF
#-----------------------------------------------------------------------------------------------------------
#
# The global conifugration array variable is meant to be initialized by the higher level
# programs prior the "GetDevice" call.
#
#  omsp_conf(interface)                     ->  Debug interface type: "uart" or "i2c_usb-iss"
#  omsp_conf(device)                        ->  Serial port device (i.e. /dev/ttyS0 or COM2:)
#  omsp_conf(baudrate)                      ->  UART communication speed
#  omsp_conf(<cpu_nr>,cpuaddr)              ->  Address of the core <cpu_nr> (i.e. I2C device address)
#
#==========================================================================================================#
global omsp_conf
 
# Initialize to default values
set omsp_conf(interface)       uart_generic
set omsp_conf(device)          /dev/ttyUSB0
set omsp_conf(baudrate)        9600
for {set i 0} {$i<128} {incr i} {
    set omsp_conf($i,cpuaddr) 0
}
 
 
#==========================================================================================================#
# GLOBAL VARIABLES: OMSP_INFO
#-----------------------------------------------------------------------------------------------------------
#
# This array variable is updated by the "GetDevice" procedure when the connection is built
# with the oMSP core.
# The array is structured as following:
#
#  omsp_info(connected)                     ->  Main Physical connection is active
#  omsp_info(<cpu_nr>,connected)            ->  Connection to CPU <cpu_nr> is active
#  omsp_info(<cpu_nr>,hw_break)             ->  Number of hardware breakpoints
#  omsp_info(<cpu_nr>,cpu_ver)              ->  From CPU_ID  : CPU Version
#  omsp_info(<cpu_nr>,user_ver)             ->  From CPU_ID  : User version
#  omsp_info(<cpu_nr>,per_size)             ->  From CPU_ID  : Peripheral address size 
#  omsp_info(<cpu_nr>,dmem_size)            ->  From CPU_ID  : Data memory size 
#  omsp_info(<cpu_nr>,pmem_size)            ->  From CPU_ID  : Program memory size
#  omsp_info(<cpu_nr>,mpy)                  ->  From CPU_ID  : Hardware multiplier
#  omsp_info(<cpu_nr>,asic)                 ->  From CPU_ID  : ASIC/FPGA version
#  omsp_info(<cpu_nr>,inst_nr)              ->  From CPU_NR  : current oMSP instance number
#  omsp_info(<cpu_nr>,total_nr)             ->  From CPU_NR  : totalnumber of oMSP instances-1
#  omsp_info(<cpu_nr>,alias)                ->  From XML File: Alias name
#  omsp_info(<cpu_nr>,extra,0,Description)  ->  From XML File: Optional Description
#  omsp_info(<cpu_nr>,extra,1,Contact)      ->  From XML File: Contact person
#  omsp_info(<cpu_nr>,extra,2,Email)        ->  From XML File: Email of contact person
#  omsp_info(<cpu_nr>,extra,3,URL)          ->  From XML File: URL of the project
#  omsp_info(<cpu_nr>,extra,4,per_size)     ->  From XML File: Custom Peripheral address size 
#  omsp_info(<cpu_nr>,extra,5,dmem_size)    ->  From XML File: Custom Data memory size 
#  omsp_info(<cpu_nr>,extra,6,pmem_size)    ->  From XML File: Custom Program memory size
#  omsp_info(<cpu_nr>,extra,?,????)         ->  From XML File: ... any extra stuff
#
#==========================================================================================================#
global omsp_info
 
# Initialize connection status 
set    omsp_info(connected) 0
 
# Support up to 128 multicore implementations
for {set i 0} {$i<128} {incr i} {
    set  omsp_info($i,connected) 0
}
 
 
#==========================================================================================================#
# SOURCE REQUIRED LIBRARIES
#==========================================================================================================#
 
set     scriptDir [file dirname [info script]]
source $scriptDir/xml.tcl
source $scriptDir/dbg_uart_generic.tcl
source $scriptDir/dbg_i2c_usb-iss.tcl
 
 
#==========================================================================================================#
# DEBUG PROCEDURES
#==========================================================================================================#
 
#=============================================================================#
# GetDevice (CpuNr)                                                           #
#-----------------------------------------------------------------------------#
# Description: Takes the target MSP430 device under UART/I2C control.         #
#              Enable the auto-freeze feature of timers when in the CPU is    #
#              stopped. This prevents an automatic watchdog reset condition.  #
#              Enables software breakpoints.                                  #
# Arguments  : CpuNr - oMSP device number to connect to.                      #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc GetDevice {CpuNr} {
 
    global omsp_conf
    global omsp_info
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set device   $omsp_conf(device)
    set baudrate $omsp_conf(baudrate)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
 
    # Open Physical connection (if not already open)
    if {$omsp_info(connected)==0} {
 
        if {![${if}::dbg_open $device $baudrate]} {
            return 0
        }
 
        # Physical connection is active
        set omsp_info(connected) 1
    }
 
 
    # Open Connection with the CPU
    if {$omsp_info($CpuNr,connected)==0} {
 
        # Connect to the CPU
        if {![${if}::dbg_connect $cpuaddr]} {
            return 0
        }
 
        # Make sure the CPU_ID is correct
        if {![VerifyCPU_ID $CpuNr]} {
            return 0
        }
 
        # Enable auto-freeze & software breakpoints
        ${if}::dbg_wr $cpuaddr CPU_CTL 0x0018
 
        # Initialize the omsp_info global variable
        GetCPU_ID $CpuNr
 
        # Get number of hardware breakpoints
        set omsp_info($CpuNr,hw_break)  [InitBreakUnits $CpuNr]
 
        # Connection with the CPU is now active
        set omsp_info($CpuNr,connected) 1
    }
 
    return 1
}
 
#=============================================================================#
# ReleaseDevice (CpuNr, Addr)                                                 #
#-----------------------------------------------------------------------------#
# Description: Releases the target device from UART/I2C control; CPU starts   #
#              execution at the specified PC address.                         #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
#              Addr  - 0xfffe: perform reset;                                 #
#                              address at reset vector loaded into PC;        #
#                      otherwise address specified by Addr loaded into PC.    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc ReleaseDevice {CpuNr Addr} {
 
    if {[expr $Addr]==[expr 0xfffe]} {
        set result 1
        set result [expr $result+[ExecutePOR $CpuNr]]
        set result [expr $result+[ReleaseCPU $CpuNr]]
    } else {
        set result 0
        set result [expr $result+[HaltCPU    $CpuNr]]
        set result [expr $result+[SetPC      $CpuNr $Addr]]
        set result [expr $result+[ReleaseCPU $CpuNr]]
    }
 
    if {$result==3} {
        return 1
    } else {
        return 0
    }
}
 
#=============================================================================#
# ExecutePOR (CpuNr)                                                          #
#-----------------------------------------------------------------------------#
# Description: Executes a power-up clear (PUC) command.                       #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc ExecutePOR {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Set PUC
    set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]
    set cpu_ctl_new [expr 0x40 | $cpu_ctl_org]
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new
 
    # Remove PUC, clear break after reset
    set cpu_ctl_org [expr 0x5f & $cpu_ctl_org]
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_org
 
    # Check status: make sure a PUC occured
    set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]
    set puc_pnd      [expr 0x04 & $cpu_stat_val]
    if {![string eq $puc_pnd 4]} {
        return 0
    }
 
    # Clear PUC pending flag
    ${if}::dbg_wr $cpuaddr CPU_STAT 0x04
 
    return 1
}
 
#=============================================================================#
# SetPC (CpuNr, Addr)                                                         #
#-----------------------------------------------------------------------------#
# Description: Loads the target device CPU's program counter (PC) with the    #
#              desired 16-bit address.                                        #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
#              Addr  - Desired 16-bit PC value (in hexadecimal).              #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc SetPC {CpuNr Addr} {
 
    return [WriteReg $CpuNr 0 $Addr]
}
 
#=============================================================================#
# HaltCPU (CpuNr)                                                             #
#-----------------------------------------------------------------------------#
# Description: Sends the target CPU into a controlled, stopped state.         #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc HaltCPU {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Stop CPU
    set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]
    set cpu_ctl_new [expr 0x01 | $cpu_ctl_org]
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new
 
    # Check status: make sure the CPU halted
    set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]
    set halted       [expr 0x01 & $cpu_stat_val]
    if {![string eq $halted 1]} {
        return 0
    }
 
    return 1
}
 
#=============================================================================#
# ReleaseCPU (CpuNr)                                                          #
#-----------------------------------------------------------------------------#
# Description: Releases the target device's CPU from the controlled, stopped  #
#              state. (Does not release the target device from debug control.)#
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc ReleaseCPU {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Start CPU
    set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]
    set cpu_ctl_new [expr 0x02 | $cpu_ctl_org]
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new
 
    # Check status: make sure the CPU runs
    set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]
    set halted       [expr 0x01 & $cpu_stat_val]
    if {![string eq $halted 0]} {
        return 0
    }
 
    return 1
}
 
#=============================================================================#
# WriteMem (CpuNr, Format, Addr, Data)                                        #
#-----------------------------------------------------------------------------#
# Description: Write a single byte or word to a given address (RAM, ROM &     #
#              Peripherals.                                                   #
# Arguments  : CpuNr  - oMSP device number to be addressed.                   #
#              Format - 0 to write a word, 1 to write a byte.                 #
#              Addr   - Destination address for data to be written.           #
#              Data   - Data value to be written.                             #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc WriteMem {CpuNr Format Addr Data} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Configure memory transfer
    #${if}::dbg_wr $cpuaddr MEM_CNT  0x0000
    ${if}::dbg_wr $cpuaddr MEM_ADDR $Addr
    ${if}::dbg_wr $cpuaddr MEM_DATA $Data
 
    # Trigger transfer
    if {$Format==0} {
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x0003
    } else {
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x000b
    }
 
    return 1
}
 
#=============================================================================#
# WriteMemQuick (CpuNr, StartAddr, DataList)                                  #
#-----------------------------------------------------------------------------#
# Description: Writes a list of words into the target device memory (RAM,     #
#              ROM & Peripherals.                                             #
# Arguments  : CpuNr     - oMSP device number to be addressed.                #
#              StartAddr - Start address of destination memory.               #
#              DataList  - List of data to be written (in hexadecimal).       #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc WriteMemQuick {CpuNr StartAddr DataList} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Single data transfer
    if {[llength $DataList]==1} {
        WriteMem $CpuNr 0 $StartAddr $DataList
 
    # Burst data transfer
    } else {
 
        # Configure & trigger memory transfer
        ${if}::dbg_wr $cpuaddr MEM_CNT  [expr [llength $DataList]-1]
        ${if}::dbg_wr $cpuaddr MEM_ADDR $StartAddr
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x0003
 
        # Send data list
        ${if}::dbg_burst_tx $cpuaddr 0 $DataList
 
    }
    return 1
}
 
#=============================================================================#
# ReadMem (CpuNr, Format, Addr)                                               #
#-----------------------------------------------------------------------------#
# Description: Read one byte or word from a specified target memory address.  #
# Arguments  : CpuNr  - oMSP device number to be addressed.                   #
#              Format - 0 to read a word, 1 to read a byte.                   #
#              Addr   - Target address for data to be read.                   #
# Result     : Data value stored in the target address memory location.       #
#=============================================================================#
proc ReadMem {CpuNr Format Addr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Single data transfer
    #${if}::dbg_wr $cpuaddr MEM_CNT  0x0000
    ${if}::dbg_wr $cpuaddr MEM_ADDR $Addr
 
    # Trigger transfer
    if {$Format==0} {
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x0001
        set mem_val [${if}::dbg_rd $cpuaddr MEM_DATA]
    } else {
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x0009
        set mem_val [${if}::dbg_rd $cpuaddr MEM_DATA]
        set mem_val [format "0x%02x" $mem_val]
    }
 
    return $mem_val
}
 
#=============================================================================#
# ReadMemQuick (CpuNr, StartAddr, Length)                                     #
#-----------------------------------------------------------------------------#
# Description: Reads a list of words from target memory.                      #
# Arguments  : CpuNr     - oMSP device number to be addressed.                #
#              StartAddr - Start address of target memory to be read.         #
#              Length    - Number of words to be read.                        #
# Result     : List of data values stored in the target memory.               #
#=============================================================================#
proc ReadMemQuick {CpuNr StartAddr Length} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Single data transfer
    if {$Length==1} {
        set mem_val [ReadMem $CpuNr 0 $StartAddr]
 
    # Burst data transfer
    } else {
 
        # Configure & trigger memory transfer
        ${if}::dbg_wr $cpuaddr MEM_CNT  [expr $Length-1]
        ${if}::dbg_wr $cpuaddr MEM_ADDR $StartAddr
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x0001
 
        # Receive Data list
        set mem_val [${if}::dbg_burst_rx $cpuaddr 0 [expr $Length*2]]
    }
    return $mem_val
}
 
#=============================================================================#
# VerifyMem (CpuNr, StartAddr, DataList)                                      #
#-----------------------------------------------------------------------------#
# Description: Performs a program verification over the given memory range.   #
# Arguments  : CpuNr     - oMSP device number to be addressed.                #
#              StartAddr - Start address of the memory to be verified.        #
#              DataList  - List of reference data (in hexadecimal).           #
# Result     : 0 if error, 1 if verification was successful.                  #
#=============================================================================#
proc VerifyMem {CpuNr StartAddr DataList {DumpOnError 0}} {
 
    # Read memory content
    set mem_val [ReadMemQuick $CpuNr $StartAddr [llength $DataList]]
 
    # Compare memory contents
    set    return_val [string equal $DataList $mem_val]
 
    # Dump memory content in files for comparison
    if {($return_val==0) && ($DumpOnError==1)} {
 
        # Delete old files
        file delete -force openmsp430-verifymem-debug-expected.mem
        file delete -force openmsp430-verifymem-debug-dumped.mem
 
        # Write expected memory content
        set fileId [open openmsp430-verifymem-debug-expected.mem "w"]
        foreach hexCode $DataList {
            puts $fileId $hexCode
        }
        close $fileId
 
        # Dump read memory content
        set fileId [open openmsp430-verifymem-debug-dumped.mem "w"]
        foreach hexCode $mem_val {
            puts $fileId $hexCode
        }
        close $fileId
    }
 
    return $return_val
}
 
#=============================================================================#
# ExecutePOR_Halt (CpuNr)                                                     #
#-----------------------------------------------------------------------------#
# Description: Same as ExecutePOR with the difference that the CPU            #
#              automatically goes in Halt mode after reset.                   #
# Arguments  : CpuNr  - oMSP device number to be addressed.                   #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc ExecutePOR_Halt {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Perform PUC
    set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]
    set cpu_ctl_new [expr 0x60 | $cpu_ctl_org]
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_org
 
    # Check status: make sure a PUC occured and that the CPU is halted
    set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]
    set puc_pnd      [expr 0x05 & $cpu_stat_val]
    if {![string eq $puc_pnd 5]} {
        return 0
    }
 
    # Clear PUC pending flag
    ${if}::dbg_wr $cpuaddr CPU_STAT 0x04
 
    return 1
}
 
#=============================================================================#
# GetCPU_ID (CpuNr)                                                           #
#-----------------------------------------------------------------------------#
# Description: This function reads the CPU_ID from the target device, update  #
#              the omsp_info global variable and return the raw CPU_ID value. #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : Return CPU_ID.                                                 #
#=============================================================================#
proc GetCPU_ID {CpuNr} {
 
    global omsp_conf
    global omsp_info
 
     # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Retreive CPU_ID/CPU_NR values
    set cpu_id_lo [${if}::dbg_rd $cpuaddr CPU_ID_LO]
    set cpu_id_hi [${if}::dbg_rd $cpuaddr CPU_ID_HI]
    set cpu_nr    [${if}::dbg_rd $cpuaddr CPU_NR]
 
    # Check if value is valid
    if {[string eq "0x" $cpu_id_lo]} {
        set cpu_id_lo "0x0000"
    }
    if {[string eq "0x" $cpu_id_hi]} {
        set cpu_id_hi "0x0000"
    }
    if {[string eq "0x" $cpu_nr]} {
        set cpu_nr    "0x0000"
    }
 
    # Remove the "0x" prefix
    regsub {0x} $cpu_id_lo {} cpu_id_lo
    regsub {0x} $cpu_id_hi {} cpu_id_hi
 
    set cpu_id    "0x$cpu_id_hi$cpu_id_lo"
    set cpu_id_lo "0x$cpu_id_lo"
    set cpu_id_hi "0x$cpu_id_hi"
 
 
    # Extract the omsp info depending on the CPU version
    set omsp_info($CpuNr,cpu_ver) [expr ($cpu_id_lo & 0x0007)+1]
    if {$omsp_info($CpuNr,cpu_ver)==1} {
        set omsp_info($CpuNr,user_ver)    --
        set omsp_info($CpuNr,per_size)   512
        set omsp_info($CpuNr,dmem_size)  [expr $cpu_id_lo]
        set omsp_info($CpuNr,pmem_size)  [expr $cpu_id_hi]
        set omsp_info($CpuNr,mpy)         --
        set omsp_info($CpuNr,asic)         0
    } else {
        set omsp_info($CpuNr,user_ver)   [expr  ($cpu_id_lo & 0x01f0)/16]
        set omsp_info($CpuNr,per_size)   [expr (($cpu_id_lo & 0xfe00)/512)  * 512]
        set omsp_info($CpuNr,dmem_size)  [expr (($cpu_id_hi & 0x03fe)/2)    * 128]
        set omsp_info($CpuNr,pmem_size)  [expr (($cpu_id_hi & 0xfc00)/1024) * 1024]
        set omsp_info($CpuNr,mpy)        [expr  ($cpu_id_hi & 0x0001)/1]
        set omsp_info($CpuNr,asic)       [expr  ($cpu_id_lo & 0x0008)/8]
    }
 
    # Get the instance number
    set omsp_info($CpuNr,inst_nr)  [expr  ($cpu_nr & 0x00ff)/1]
    set omsp_info($CpuNr,total_nr) [expr  ($cpu_nr & 0xff00)/256]
 
    # Get alias from the XML file
    set omsp_info($CpuNr,alias) [GetChipAlias $CpuNr]
 
    return $cpu_id
}
 
#=============================================================================#
# GetCPU_ID_SIZE (CpuNr)                                                      #
#-----------------------------------------------------------------------------#
# Description: Returns the Data and Program memory sizes of the connected     #
#              device.                                                        #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : Return "PMEM_SIZE DMEM_SIZE PER_SIZE" in byte.                 #
#=============================================================================#
proc GetCPU_ID_SIZE {CpuNr} {
 
    global omsp_info
 
    # Check if custom sizes are available from the XML file
    set custom_pmem [array names omsp_info -glob "$CpuNr,extra,*,pmem_size"]
    set custom_dmem [array names omsp_info -glob "$CpuNr,extra,*,dmem_size"]
    set custom_per  [array names omsp_info -glob "$CpuNr,extra,*,per_size"]
 
    # Program memory size
    if {$custom_pmem != ""} {
        set pmem_size $omsp_info($custom_pmem)
    } elseif {[info exists omsp_info($CpuNr,pmem_size)]} {
        set pmem_size $omsp_info($CpuNr,pmem_size)
    } else {
        set pmem_size -1
    }
 
    # Data memory size
    if {$custom_dmem != ""} {
        set dmem_size $omsp_info($custom_dmem)
    } elseif {[info exists omsp_info($CpuNr,dmem_size)]} {
        set dmem_size $omsp_info($CpuNr,dmem_size)
    } else {
        set dmem_size -1
    }
 
    # Peripheral address space size
    if {$custom_per != ""} {
        set per_size $omsp_info($custom_per)
    } elseif {[info exists omsp_info($CpuNr,per_size)]} {
        set per_size $omsp_info($CpuNr,per_size)
    } else {
        set per_size -1
    }
 
    return "$pmem_size $dmem_size $per_size"
}
 
#=============================================================================#
# VerifyCPU_ID (CpuNr)                                                        #
#-----------------------------------------------------------------------------#
# Description: Read and check the CPU_ID from the target device.              #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc VerifyCPU_ID {CpuNr} {
 
    global omsp_conf
    global omsp_info
 
    set cpu_id_full [GetCPU_ID $CpuNr]
 
    if {[string eq "0x00000000" $cpu_id_full] |
        ([string length $cpu_id_full]!=10)    |
        ($omsp_info($CpuNr,cpu_ver) >3)       } {
 
        puts "\n"
        puts "ERROR: cpu_id not valid: $cpu_id_full"
        puts ""
        puts "         --------------------------------------------------------------"
        puts "       !!!! What next:                                               !!!!"
        if {[regexp {i2c_} $omsp_conf(interface)]} {
            puts "       !!!!    - double check the I2C address of the target core.    !!!!"
        }
        puts "       !!!!    - check that you are properly connected to the board. !!!!"
        puts "       !!!!    - try reseting the serial debug interface (or CPU).   !!!!"
        puts "         --------------------------------------------------------------"
        puts ""
 
        return 0
    }
    return 1
}
 
#=============================================================================#
# WriteReg (CpuNr, Addr,  Data)                                               #
#-----------------------------------------------------------------------------#
# Description: Write a word to the the selected CPU register.                 #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
#              Addr  - Target CPU Register number.                            #
#              Data  - Data value to be written.                              #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc WriteReg {CpuNr Addr Data} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Configure memory transfer
    #${if}::dbg_wr $cpuaddr MEM_CNT  0x0000
    ${if}::dbg_wr $cpuaddr MEM_ADDR $Addr
    ${if}::dbg_wr $cpuaddr MEM_DATA $Data
 
    # Trigger transfer
    ${if}::dbg_wr $cpuaddr MEM_CTL  0x0007
 
    return 1
}
 
#=============================================================================#
# WriteRegAll (CpuNr, DataList)                                               #
#-----------------------------------------------------------------------------#
# Description: Write all CPU registers.                                       #
# Arguments  : CpuNr     - oMSP device number to be addressed.                #
#              DataList  - Data values to be written.                         #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc WriteRegAll {CpuNr DataList} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Configure & trigger memory transfer
    ${if}::dbg_wr $cpuaddr MEM_CNT  [expr [llength $DataList]-1]
    ${if}::dbg_wr $cpuaddr MEM_ADDR 0x0000
    ${if}::dbg_wr $cpuaddr MEM_CTL  0x0007
 
    # Send data list
    ${if}::dbg_burst_tx $cpuaddr 0 $DataList
 
    return 1
}
 
#=============================================================================#
# ReadReg (CpuNr, Addr)                                                       #
#-----------------------------------------------------------------------------#
# Description: Read the value from the selected CPU register.                 #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
#              Addr  - Target CPU Register number.                            #
# Result     : Data value stored in the selected CPU register.                #
#=============================================================================#
proc ReadReg {CpuNr Addr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Single data transfer
    ${if}::dbg_wr $cpuaddr MEM_CNT  0x0000
    ${if}::dbg_wr $cpuaddr MEM_ADDR $Addr
 
    # Trigger transfer
    ${if}::dbg_wr $cpuaddr MEM_CTL  0x0005
    set reg_val [${if}::dbg_rd $cpuaddr MEM_DATA]
 
    return $reg_val
}
 
#=============================================================================#
# ReadRegAll (CpuNr)                                                          #
#-----------------------------------------------------------------------------#
# Description: Read all CPU registers.                                        #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : Current values of all CPU registers.                           #
#=============================================================================#
proc ReadRegAll {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Configure & trigger memory transfer
    ${if}::dbg_wr $cpuaddr MEM_CNT  0x000f
    ${if}::dbg_wr $cpuaddr MEM_ADDR 0x0000
    ${if}::dbg_wr $cpuaddr MEM_CTL  0x0005
 
    # Receive Data list
    set reg_val [${if}::dbg_burst_rx $cpuaddr 0 32]
 
    return $reg_val
}
 
#=============================================================================#
# WriteMemQuick8 (CpuNr, StartAddr, DataList)                                 #
#-----------------------------------------------------------------------------#
# Description: Writes a list of bytes into the target device memory (RAM,     #
#              ROM & Peripherals.                                             #
# Arguments  : CpuNr     - oMSP device number to be addressed.                #
#              StartAddr - Start address of destination memory.               #
#              DataList  - List of data to be written (in hexadecimal).       #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc WriteMemQuick8 {CpuNr StartAddr DataList} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Single data transfer
    if {[llength $DataList]==1} {
        WriteMem $CpuNr 1 $StartAddr $DataList
 
    # Burst data transfer
    } else {
 
        # Configure & trigger memory transfer
        ${if}::dbg_wr $cpuaddr MEM_CNT  [expr [llength $DataList]-1]
        ${if}::dbg_wr $cpuaddr MEM_ADDR $StartAddr
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x000b
 
        # Send data list
        ${if}::dbg_burst_tx $cpuaddr 1 $DataList
 
    }
    return 1
}
 
#=============================================================================#
# ReadMemQuick8 (CpuNr, StartAddr, Length)                                    #
#-----------------------------------------------------------------------------#
# Description: Reads a list of bytes from target memory.                      #
# Arguments  : CpuNr     - oMSP device number to be addressed.                #
#              StartAddr - Start address of target memory to be read.         #
#              Length    - Number of bytes to be read.                        #
# Result     : List of data values stored in the target memory.               #
#=============================================================================#
proc ReadMemQuick8 {CpuNr StartAddr Length} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Single data transfer
    if {$Length==1} {
        set mem_val [ReadMem $CpuNr 1 $StartAddr]
 
    # Burst data transfer
    } else {
 
        # Configure & trigger memory transfer
        ${if}::dbg_wr $cpuaddr MEM_CNT  [expr $Length-1]
        ${if}::dbg_wr $cpuaddr MEM_ADDR $StartAddr
        ${if}::dbg_wr $cpuaddr MEM_CTL  0x0009
 
        # Receive Data list
        set mem_val [${if}::dbg_burst_rx $cpuaddr 1 $Length]
    }
 
    return $mem_val
}
 
#=============================================================================#
# StepCPU (CpuNr)                                                             #
#-----------------------------------------------------------------------------#
# Description: Performs a CPU incremental step.                               #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc StepCPU {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Check if the device is halted. If not, stop it.
    set cpu_ctl_val [${if}::dbg_rd $cpuaddr CPU_CTL]
    set cpu_ctl_new [expr 0x04 | $cpu_ctl_val]
    ${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new
 
    return 1
}
 
#=============================================================================#
# EraseRAM (CpuNr)                                                            #
#-----------------------------------------------------------------------------#
# Description: Erase RAM.                                                     #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc EraseRAM {CpuNr} {
 
    global omsp_info
 
    set ram_size [lindex [GetCPU_ID_SIZE $CpuNr] 1]
    set per_size [lindex [GetCPU_ID_SIZE $CpuNr] 2]
 
    if {$ram_size!=-1} {
 
        set DataList ""
        for {set i 0} {$i<$ram_size} {incr i} {
            lappend DataList 0x00
        }
 
        WriteMemQuick8 $CpuNr $per_size $DataList
 
        return 1
    }
    return 0
}
 
#=============================================================================#
# EraseROM (CpuNr)                                                            #
#-----------------------------------------------------------------------------#
# Description: Erase ROM.                                                     #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc EraseROM {CpuNr} {
 
    set rom_size  [lindex [GetCPU_ID_SIZE $CpuNr] 0]
    set rom_start [expr 0x10000-$rom_size]
 
    if {$rom_size!=-1} {
        set DataList ""
        for {set i 0} {$i<$rom_size} {incr i} {
            lappend DataList 0x00
        }
 
        WriteMemQuick8 $CpuNr $rom_start $DataList
 
        return 1
    }
    return 0
}
 
#=============================================================================#
# InitBreakUnits(CpuNr)                                                       #
#-----------------------------------------------------------------------------#
# Description: Initialize the hardware breakpoint units.                      #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : Number of hardware breakpoint units.                           #
#=============================================================================#
proc InitBreakUnits {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Initialize each hardware breakpoint unit and count how many of them
    # are present in the current core
    set num_brk_units 0
    for {set i 0} {$i<4} {incr i} {
 
        ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR0" 0x1234
        set new_val [${if}::dbg_rd $cpuaddr "BRK$i\_ADDR0"]
        if {$new_val=="0x1234"} {
            incr num_brk_units
            ${if}::dbg_wr $cpuaddr "BRK$i\_CTL"   0x00
            ${if}::dbg_wr $cpuaddr "BRK$i\_STAT"  0xff
            ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR0" 0x0000
            ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR1" 0x0000
        }
    }
    return $num_brk_units
}
 
#=============================================================================#
# SetHWBreak(CpuNr, Type, Addr, Rd, Wr)                                       #
#-----------------------------------------------------------------------------#
# Description: Set data/instruction breakpoint on a given memory address.     #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
#              Type  - 1 for instruction break, 0 for data break.             #
#              Addr  - Memory address of the data breakpoint.                 #
#              Rd    - Breakpoint on read access.                             #
#              Wr    - Breakpoint on write access.                            #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc SetHWBreak {CpuNr Type Addr Rd Wr} {
 
    global omsp_info
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Compute the BRKx_CTL corresponding value
    set brk_ctl_ref [format "0x%02x" [expr 8*$Type+4+2*$Wr+$Rd]]
 
    # First look for utilized units with correct BRKx_CTL attributes
    for {set i 0} {$i<$omsp_info($CpuNr,hw_break)} {incr i} {
        if {[string eq [${if}::dbg_rd $cpuaddr "BRK$i\_CTL"] $brk_ctl_ref]} {
 
            # Look if there is an address free
            set brk_addr0 [${if}::dbg_rd $cpuaddr "BRK$i\_ADDR0"]
            set brk_addr1 [${if}::dbg_rd $cpuaddr "BRK$i\_ADDR1"]
            if {[string eq $brk_addr0 $brk_addr1]} {
                ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR1" $Addr
                return 1
            }
        }
    }
 
    # Then look for a free unit
    for {set i 0} {$i<$omsp_info($CpuNr,hw_break)} {incr i} {
        if {[string eq [${if}::dbg_rd $cpuaddr "BRK$i\_CTL"] 0x00]} {
            ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR0" $Addr
            ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR1" $Addr
            ${if}::dbg_wr $cpuaddr "BRK$i\_CTL"   $brk_ctl_ref
            return 1
        }
    }
 
    return 0
}
 
#=============================================================================#
# ClearHWBreak(CpuNr, Type, Addr)                                             #
#-----------------------------------------------------------------------------#
# Description: Clear the data/instruction breakpoint set on the provided      #
#              memory address.                                                #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
#              Type  - 1 for instruction break, 0 for data break.             #
#              Addr  - Data address of the breakpoint to be cleared.          #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc ClearHWBreak {CpuNr Type Addr} {
 
    global omsp_info
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    for {set i 0} {$i<$omsp_info($CpuNr,hw_break)} {incr i} {
 
        # Check if the unit works on Data or Instructions)
        set brk_ctl [${if}::dbg_rd $cpuaddr "BRK$i\_CTL"]
        if {[expr $brk_ctl & 0x08]==[expr 8*$Type]} {
 
            # Look for the matching address
            set brk_addr0 [${if}::dbg_rd $cpuaddr "BRK$i\_ADDR0"]
            set brk_addr1 [${if}::dbg_rd $cpuaddr "BRK$i\_ADDR1"]
 
            if {[string eq $brk_addr0 $brk_addr1] && [string eq $brk_addr0 $Addr]} {
                ${if}::dbg_wr $cpuaddr "BRK$i\_CTL"   0x00
                ${if}::dbg_wr $cpuaddr "BRK$i\_STAT"  0xff
                ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR0" 0x0000
                ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR1" 0x0000
                return 1
            }
            if {[string eq $brk_addr0 $Addr]} {
                ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR0" $brk_addr1
                return 1
            }
            if {[string eq $brk_addr1 $Addr]} {
                ${if}::dbg_wr $cpuaddr "BRK$i\_ADDR1" $brk_addr0
                return 1
            }
        }
    }
    return 1
}
 
#=============================================================================#
# IsHalted (CpuNr)                                                            #
#-----------------------------------------------------------------------------#
# Description: Check if the CPU is currently stopped or not.                  #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if CPU is running, 1 if stopped.                             #
#=============================================================================#
proc IsHalted {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Check current target status
    set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]
    set halted       [expr 0x01 & $cpu_stat_val]
 
    return $halted
}
 
#=============================================================================#
# ClrStatus (CpuNr)                                                           #
#-----------------------------------------------------------------------------#
# Description: Clear the status bit of the CPU_STAT register.                 #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : 0 if error, 1 otherwise.                                       #
#=============================================================================#
proc ClrStatus {CpuNr} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
    set cpuaddr  $omsp_conf($CpuNr,cpuaddr)
 
    # Clear status
    ${if}::dbg_wr $cpuaddr CPU_STAT  0xff
    ${if}::dbg_wr $cpuaddr BRK0_STAT 0xff
    ${if}::dbg_wr $cpuaddr BRK1_STAT 0xff
    ${if}::dbg_wr $cpuaddr BRK2_STAT 0xff
    ${if}::dbg_wr $cpuaddr BRK3_STAT 0xff
 
    return 1
}
 
#=============================================================================#
# GetAllowedSpeeds()                                                          #
#-----------------------------------------------------------------------------#
# Description: Return the list of allowed speed configurations for the        #
#              selected adapter.                                              #
# Arguments  : None.                                                          #
# Result     : list of modes.                                                 #
#=============================================================================#
proc GetAllowedSpeeds {} {
 
    global omsp_conf
 
    # Copy global variable to local for code readability
    set if       $omsp_conf(interface)
 
    # Return list of allowed speed configuration
    return [${if}::get_allowed_speeds]
}
 
#=============================================================================#
# GetChipAlias (CpuNr)                                                        #
#-----------------------------------------------------------------------------#
# Description: Parse the chip alias XML file an return the alias name.        #
# Arguments  : CpuNr - oMSP device number to be addressed.                    #
# Result     : Chip Alias.                                                    #
#=============================================================================#
proc GetChipAlias {CpuNr} {
 
    global omsp_info
 
    # Set XML file name
    if {[info exists  ::env(OMSP_XML_FILE)]} {
        set xmlFile $::env(OMSP_XML_FILE)
    } else {
        set xmlFile [file normalize "$::scriptDir/../../omsp_alias.xml"]
    }
 
    # Read XML file
    if {[file exists $xmlFile]} {
        set fp [open $xmlFile r]
        set xmlData [read $fp]
        close $fp
    } else {
        puts "WARNING: the XML alias file was not found - $xmlFile"
        return ""
    }
 
    # Analyze XML file
    ::XML::Init $xmlData
    set wellFormed [::XML::IsWellFormed]
    if {$wellFormed ne ""} {
        puts "WARNING: the XML alias file is not well-formed - $xmlFile \n $wellFormed"
        return ""
    }
 
    #========================================================================#
    # Create list from XML file                                              #
    #========================================================================#
    set aliasList    ""
    set currentALIAS ""
    set currentTYPE  ""
    set currentTAG   ""
    while {1} {
        foreach {type val attr etype} [::XML::NextToken] break
        if {$type == "EOF"} break
 
        # Detect the start of a new alias description
        if {($type == "XML") & ($val == "omsp:alias") & ($etype == "START")} {
            set aliasName ""
            regexp {val=\"(.*)\"} $attr whole_match aliasName
            lappend aliasList $aliasName
            set currentALIAS $aliasName
        }
 
        # Detect start and end of the configuration field
        if {($type == "XML") & ($val == "omsp:configuration")} {
 
            if {($etype == "START")} {
                set currentTYPE  "config"
 
            } elseif {($etype == "END")} {
                set currentTYPE  ""
            }
        }
 
        # Detect start and end of the extra_info field
        if {($type == "XML") & ($val == "omsp:extra_info")} {
 
            if {($etype == "START")} {
                set currentTYPE  "extra_info"
                set idx 0
 
            } elseif {($etype == "END")} {
                set currentTYPE  ""
            }
        }
 
        # Detect the current TAG
        if {($type == "XML") & ($etype == "START")} {
            regsub {omsp:} $val {} val
            set currentTAG $val
        }
 
        if {($type == "TXT")} {
            if {$currentTYPE=="extra_info"} {
                set alias($currentALIAS,$currentTYPE,$idx,$currentTAG) $val
                incr idx
            } else {
                set alias($currentALIAS,$currentTYPE,$currentTAG) $val
            }
        }
    }
 
    #========================================================================#
    # Check if the current OMSP_INFO has an alias match                      #
    #========================================================================#
    foreach currentALIAS $aliasList {
 
        set aliasCONFIG [array names alias -glob "$currentALIAS,config,*"]
        set aliasEXTRA  [lsort -increasing [array names alias -glob "$currentALIAS,extra_info,*"]]
 
        #----------------------------------#
        # Is current alias matching ?      #
        #----------------------------------#
        set match       1
        set description ""
        foreach currentCONFIG $aliasCONFIG {
 
            regsub "$currentALIAS,config," $currentCONFIG {} configName
 
            if {![string eq $omsp_info($CpuNr,$configName) $alias($currentCONFIG)]} {
                set match 0
            }
        }
 
        #----------------------------------#
        # If matching, get the extra infos #
        #----------------------------------#
        if {$match} {
 
            set idx 0
            foreach currentEXTRA $aliasEXTRA {
                regsub "$currentALIAS,extra_info," $currentEXTRA {} extraName
                set omsp_info($CpuNr,extra,$idx,$extraName) $alias($currentEXTRA)
                incr idx
            }
            return $currentALIAS
        }
    }
 
    return ""
}

Line No.	Rev	Author	Line
1	158	olivier.gi	`#-----------------------------------------------------------------------------------------------------------`
2	2	olivier.gi	`# Copyright (C) 2001 Authors`
3			`#`
4			`# This source file may be used and distributed without restriction provided`
5			`# that this copyright statement is not removed from the file and that any`
6			`# derivative work contains the original copyright notice and the associated`
7			`# disclaimer.`
8			`#`
9			`# This source file is free software; you can redistribute it and/or modify`
10			`# it under the terms of the GNU Lesser General Public License as published`
11			`# by the Free Software Foundation; either version 2.1 of the License, or`
12			`# (at your option) any later version.`
13			`#`
14			`# This source is distributed in the hope that it will be useful, but WITHOUT`
15			`# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
16			`# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public`
17			`# License for more details.`
18			`#`
19			`# You should have received a copy of the GNU Lesser General Public License`
20			`# along with this source; if not, write to the Free Software Foundation,`
21			`# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA`
22			`#`
23	158	olivier.gi	`#-----------------------------------------------------------------------------------------------------------`
24	2	olivier.gi	`#`
25			`# File Name: dbg_functions.tcl`
26			`#`
27	15	olivier.gi	`# Author(s):`
28			`# - Olivier Girard, olgirard@gmail.com`
29			`#`
30	158	olivier.gi	`#-----------------------------------------------------------------------------------------------------------`
31	15	olivier.gi	`# $Rev: 172 $`
32			`# $LastChangedBy: olivier.girard $`
33			`# $LastChangedDate: 2012-12-28 00:06:56 +0100 (Fri, 28 Dec 2012) $`
34	158	olivier.gi	`#-----------------------------------------------------------------------------------------------------------`
35	15	olivier.gi	`#`
36	2	olivier.gi	`# Description: Main utility functions for the openMSP430 serial debug`
37			`# interface.`
38			`#`
39			`# The following functions are implemented according to the SLAA149`
40			`# application report from TI (Programming a Flash-Based MSP430 Using the`
41			`# JTAG Interface):`
42			`#`
43	158	olivier.gi	`# - GetDevice (CpuNr)`
44			`# - ReleaseDevice (CpuNr, Addr)`
45			`# - ExecutePOR (CpuNr)`
46			`# - SetPC (CpuNr, Addr)`
47			`# - HaltCPU (CpuNr)`
48			`# - ReleaseCPU (CpuNr)`
49			`# - WriteMem (CpuNr, Format, Addr, Data)`
50			`# - WriteMemQuick (CpuNr, StartAddr, DataList)`
51			`# - ReadMem (CpuNr, Format, Addr)`
52			`# - ReadMemQuick (CpuNr, StartAddr, Length)`
53			`# - VerifyMem (CpuNr, StartAddr, DataList)`
54	2	olivier.gi	`#`
55			`#`
56			`# The following have been added:`
57			`#`
58	158	olivier.gi	`# - ExecutePOR_Halt (CpuNr)`
59			`# - GetCPU_ID (CpuNr)`
60			`# - GetCPU_ID_SIZE (CpuNr)`
61			`# - VerifyCPU_ID (CpuNr)`
62			`# - WriteReg (CpuNr, Addr, Data)`
63			`# - WriteRegAll (CpuNr, DataList)`
64			`# - ReadReg (CpuNr, Addr)`
65			`# - ReadRegAll (CpuNr)`
66			`# - WriteMemQuick8 (CpuNr, StartAddr, DataList)`
67			`# - ReadMemQuick8 (CpuNr, StartAddr, Length)`
68			`# - StepCPU (CpuNr)`
69			`# - EraseRAM (CpuNr)`
70			`# - EraseROM (CpuNr)`
71			`# - InitBreakUnits (CpuNr)`
72			`# - SetHWBreak (CpuNr, Type, Addr, Rd, Wr)`
73			`# - ClearHWBreak (CpuNr, Type, Addr)`
74			`# - IsHalted (CpuNr)`
75			`# - ClrStatus (CpuNr)`
76			`# - GetChipAlias (CpuNr)`
77			`# - GetAllowedSpeeds()`
78	2	olivier.gi	`#`
79	158	olivier.gi	`#-----------------------------------------------------------------------------------------------------------`
80	2	olivier.gi
81	158	olivier.gi	`#==========================================================================================================#`
82			`# GLOBAL VARIABLES: OMSP_CONF`
83			`#-----------------------------------------------------------------------------------------------------------`
84			`#`
85			`# The global conifugration array variable is meant to be initialized by the higher level`
86			`# programs prior the "GetDevice" call.`
87			`#`
88			`# omsp_conf(interface) -> Debug interface type: "uart" or "i2c_usb-iss"`
89			`# omsp_conf(device) -> Serial port device (i.e. /dev/ttyS0 or COM2:)`
90			`# omsp_conf(baudrate) -> UART communication speed`
91			`# omsp_conf(<cpu_nr>,cpuaddr) -> Address of the core <cpu_nr> (i.e. I2C device address)`
92			`#`
93			`#==========================================================================================================#`
94			`global omsp_conf`
95
96			`# Initialize to default values`
97			`set omsp_conf(interface) uart_generic`
98			`set omsp_conf(device) /dev/ttyUSB0`
99			`set omsp_conf(baudrate) 9600`
100			`for {set i 0} {$i<128} {incr i} {`
101			`set omsp_conf($i,cpuaddr) 0`
102			`}`
103
104
105			`#==========================================================================================================#`
106			`# GLOBAL VARIABLES: OMSP_INFO`
107			`#-----------------------------------------------------------------------------------------------------------`
108			`#`
109			`# This array variable is updated by the "GetDevice" procedure when the connection is built`
110			`# with the oMSP core.`
111			`# The array is structured as following:`
112			`#`
113			`# omsp_info(connected) -> Main Physical connection is active`
114			`# omsp_info(<cpu_nr>,connected) -> Connection to CPU <cpu_nr> is active`
115			`# omsp_info(<cpu_nr>,hw_break) -> Number of hardware breakpoints`
116			`# omsp_info(<cpu_nr>,cpu_ver) -> From CPU_ID : CPU Version`
117			`# omsp_info(<cpu_nr>,user_ver) -> From CPU_ID : User version`
118			`# omsp_info(<cpu_nr>,per_size) -> From CPU_ID : Peripheral address size`
119			`# omsp_info(<cpu_nr>,dmem_size) -> From CPU_ID : Data memory size`
120			`# omsp_info(<cpu_nr>,pmem_size) -> From CPU_ID : Program memory size`
121			`# omsp_info(<cpu_nr>,mpy) -> From CPU_ID : Hardware multiplier`
122			`# omsp_info(<cpu_nr>,asic) -> From CPU_ID : ASIC/FPGA version`
123			`# omsp_info(<cpu_nr>,inst_nr) -> From CPU_NR : current oMSP instance number`
124			`# omsp_info(<cpu_nr>,total_nr) -> From CPU_NR : totalnumber of oMSP instances-1`
125			`# omsp_info(<cpu_nr>,alias) -> From XML File: Alias name`
126			`# omsp_info(<cpu_nr>,extra,0,Description) -> From XML File: Optional Description`
127			`# omsp_info(<cpu_nr>,extra,1,Contact) -> From XML File: Contact person`
128			`# omsp_info(<cpu_nr>,extra,2,Email) -> From XML File: Email of contact person`
129			`# omsp_info(<cpu_nr>,extra,3,URL) -> From XML File: URL of the project`
130			`# omsp_info(<cpu_nr>,extra,4,per_size) -> From XML File: Custom Peripheral address size`
131			`# omsp_info(<cpu_nr>,extra,5,dmem_size) -> From XML File: Custom Data memory size`
132			`# omsp_info(<cpu_nr>,extra,6,pmem_size) -> From XML File: Custom Program memory size`
133			`# omsp_info(<cpu_nr>,extra,?,????) -> From XML File: ... any extra stuff`
134			`#`
135			`#==========================================================================================================#`
136	110	olivier.gi	`global omsp_info`
137	158	olivier.gi
138			`# Initialize connection status`
139	110	olivier.gi	`set omsp_info(connected) 0`
140	2	olivier.gi
141	158	olivier.gi	`# Support up to 128 multicore implementations`
142			`for {set i 0} {$i<128} {incr i} {`
143			`set omsp_info($i,connected) 0`
144			`}`
145
146
147			`#==========================================================================================================#`
148	2	olivier.gi	`# SOURCE REQUIRED LIBRARIES`
149	158	olivier.gi	`#==========================================================================================================#`
150
151	110	olivier.gi	`set scriptDir [file dirname [info script]]`
152			`source $scriptDir/xml.tcl`
153	158	olivier.gi	`source $scriptDir/dbg_uart_generic.tcl`
154			`source $scriptDir/dbg_i2c_usb-iss.tcl`
155	2	olivier.gi
156	110	olivier.gi
157	158	olivier.gi	`#==========================================================================================================#`
158			`# DEBUG PROCEDURES`
159			`#==========================================================================================================#`
160
161	2	olivier.gi	`#=============================================================================#`
162	158	olivier.gi	`# GetDevice (CpuNr) #`
163	2	olivier.gi	`#-----------------------------------------------------------------------------#`
164	158	olivier.gi	`# Description: Takes the target MSP430 device under UART/I2C control. #`
165			`# Enable the auto-freeze feature of timers when in the CPU is #`
166			`# stopped. This prevents an automatic watchdog reset condition. #`
167			`# Enables software breakpoints. #`
168			`# Arguments : CpuNr - oMSP device number to connect to. #`
169			`# Result : 0 if error, 1 otherwise. #`
170			`#=============================================================================#`
171			`proc GetDevice {CpuNr} {`
172
173			`global omsp_conf`
174			`global omsp_info`
175
176			`# Copy global variable to local for code readability`
177			`set if $omsp_conf(interface)`
178			`set device $omsp_conf(device)`
179			`set baudrate $omsp_conf(baudrate)`
180			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
181
182
183			`# Open Physical connection (if not already open)`
184			`if {$omsp_info(connected)==0} {`
185
186			`if {![${if}::dbg_open $device $baudrate]} {`
187			`return 0`
188			`}`
189
190			`# Physical connection is active`
191			`set omsp_info(connected) 1`
192			`}`
193
194
195			`# Open Connection with the CPU`
196			`if {$omsp_info($CpuNr,connected)==0} {`
197
198			`# Connect to the CPU`
199			`if {![${if}::dbg_connect $cpuaddr]} {`
200			`return 0`
201			`}`
202
203			`# Make sure the CPU_ID is correct`
204			`if {![VerifyCPU_ID $CpuNr]} {`
205			`return 0`
206			`}`
207
208			`# Enable auto-freeze & software breakpoints`
209			`${if}::dbg_wr $cpuaddr CPU_CTL 0x0018`
210
211			`# Initialize the omsp_info global variable`
212			`GetCPU_ID $CpuNr`
213
214			`# Get number of hardware breakpoints`
215			`set omsp_info($CpuNr,hw_break) [InitBreakUnits $CpuNr]`
216
217			`# Connection with the CPU is now active`
218			`set omsp_info($CpuNr,connected) 1`
219			`}`
220
221			`return 1`
222			`}`
223
224			`#=============================================================================#`
225			`# ReleaseDevice (CpuNr, Addr) #`
226			`#-----------------------------------------------------------------------------#`
227			`# Description: Releases the target device from UART/I2C control; CPU starts #`
228			`# execution at the specified PC address. #`
229			`# Arguments : CpuNr - oMSP device number to be addressed. #`
230			`# Addr - 0xfffe: perform reset; #`
231			`# address at reset vector loaded into PC; #`
232			`# otherwise address specified by Addr loaded into PC. #`
233			`# Result : 0 if error, 1 otherwise. #`
234			`#=============================================================================#`
235			`proc ReleaseDevice {CpuNr Addr} {`
236
237			`if {[expr $Addr]==[expr 0xfffe]} {`
238			`set result 1`
239			`set result [expr $result+[ExecutePOR $CpuNr]]`
240			`set result [expr $result+[ReleaseCPU $CpuNr]]`
241			`} else {`
242			`set result 0`
243			`set result [expr $result+[HaltCPU $CpuNr]]`
244			`set result [expr $result+[SetPC $CpuNr $Addr]]`
245			`set result [expr $result+[ReleaseCPU $CpuNr]]`
246			`}`
247
248			`if {$result==3} {`
249			`return 1`
250			`} else {`
251			`return 0`
252			`}`
253			`}`
254
255			`#=============================================================================#`
256			`# ExecutePOR (CpuNr) #`
257			`#-----------------------------------------------------------------------------#`
258	2	olivier.gi	`# Description: Executes a power-up clear (PUC) command. #`
259	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
260	2	olivier.gi	`# Result : 0 if error, 1 otherwise. #`
261			`#=============================================================================#`
262	158	olivier.gi	`proc ExecutePOR {CpuNr} {`
263	2	olivier.gi
264	158	olivier.gi	`global omsp_conf`
265
266			`# Copy global variable to local for code readability`
267			`set if $omsp_conf(interface)`
268			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
269
270	2	olivier.gi	`# Set PUC`
271	158	olivier.gi	`set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]`
272	2	olivier.gi	`set cpu_ctl_new [expr 0x40 \| $cpu_ctl_org]`
273	158	olivier.gi	`${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new`
274	2	olivier.gi
275			`# Remove PUC, clear break after reset`
276			`set cpu_ctl_org [expr 0x5f & $cpu_ctl_org]`
277	158	olivier.gi	`${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_org`
278	2	olivier.gi
279			`# Check status: make sure a PUC occured`
280	158	olivier.gi	`set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]`
281	2	olivier.gi	`set puc_pnd [expr 0x04 & $cpu_stat_val]`
282			`if {![string eq $puc_pnd 4]} {`
283	158	olivier.gi	`return 0`
284	2	olivier.gi	`}`
285
286			`# Clear PUC pending flag`
287	158	olivier.gi	`${if}::dbg_wr $cpuaddr CPU_STAT 0x04`
288	2	olivier.gi
289	110	olivier.gi	`return 1`
290	2	olivier.gi	`}`
291
292			`#=============================================================================#`
293	158	olivier.gi	`# SetPC (CpuNr, Addr) #`
294	2	olivier.gi	`#-----------------------------------------------------------------------------#`
295			`# Description: Loads the target device CPU's program counter (PC) with the #`
296			`# desired 16-bit address. #`
297	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
298			`# Addr - Desired 16-bit PC value (in hexadecimal). #`
299	2	olivier.gi	`# Result : 0 if error, 1 otherwise. #`
300			`#=============================================================================#`
301	158	olivier.gi	`proc SetPC {CpuNr Addr} {`
302	2	olivier.gi
303	158	olivier.gi	`return [WriteReg $CpuNr 0 $Addr]`
304	2	olivier.gi	`}`
305
306			`#=============================================================================#`
307	158	olivier.gi	`# HaltCPU (CpuNr) #`
308	2	olivier.gi	`#-----------------------------------------------------------------------------#`
309			`# Description: Sends the target CPU into a controlled, stopped state. #`
310	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
311	2	olivier.gi	`# Result : 0 if error, 1 otherwise. #`
312			`#=============================================================================#`
313	158	olivier.gi	`proc HaltCPU {CpuNr} {`
314	2	olivier.gi
315	158	olivier.gi	`global omsp_conf`
316	2	olivier.gi
317	158	olivier.gi	`# Copy global variable to local for code readability`
318			`set if $omsp_conf(interface)`
319			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
320
321	2	olivier.gi	`# Stop CPU`
322	158	olivier.gi	`set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]`
323	2	olivier.gi	`set cpu_ctl_new [expr 0x01 \| $cpu_ctl_org]`
324	158	olivier.gi	`${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new`
325	2	olivier.gi
326			`# Check status: make sure the CPU halted`
327	158	olivier.gi	`set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]`
328	2	olivier.gi	`set halted [expr 0x01 & $cpu_stat_val]`
329			`if {![string eq $halted 1]} {`
330	158	olivier.gi	`return 0`
331	2	olivier.gi	`}`
332
333	158	olivier.gi	`return 1`
334	2	olivier.gi	`}`
335
336			`#=============================================================================#`
337	158	olivier.gi	`# ReleaseCPU (CpuNr) #`
338	2	olivier.gi	`#-----------------------------------------------------------------------------#`
339			`# Description: Releases the target device's CPU from the controlled, stopped #`
340			`# state. (Does not release the target device from debug control.)#`
341	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
342	2	olivier.gi	`# Result : 0 if error, 1 otherwise. #`
343			`#=============================================================================#`
344	158	olivier.gi	`proc ReleaseCPU {CpuNr} {`
345	2	olivier.gi
346	158	olivier.gi	`global omsp_conf`
347	2	olivier.gi
348	158	olivier.gi	`# Copy global variable to local for code readability`
349			`set if $omsp_conf(interface)`
350			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
351
352	2	olivier.gi	`# Start CPU`
353	158	olivier.gi	`set cpu_ctl_org [${if}::dbg_rd $cpuaddr CPU_CTL]`
354	2	olivier.gi	`set cpu_ctl_new [expr 0x02 \| $cpu_ctl_org]`
355	158	olivier.gi	`${if}::dbg_wr $cpuaddr CPU_CTL $cpu_ctl_new`
356	2	olivier.gi
357			`# Check status: make sure the CPU runs`
358	158	olivier.gi	`set cpu_stat_val [${if}::dbg_rd $cpuaddr CPU_STAT]`
359	2	olivier.gi	`set halted [expr 0x01 & $cpu_stat_val]`
360			`if {![string eq $halted 0]} {`
361	158	olivier.gi	`return 0`
362	2	olivier.gi	`}`
363
364	124	olivier.gi	`return 1`
365	2	olivier.gi	`}`
366
367			`#=============================================================================#`
368	158	olivier.gi	`# WriteMem (CpuNr, Format, Addr, Data) #`
369	2	olivier.gi	`#-----------------------------------------------------------------------------#`
370			`# Description: Write a single byte or word to a given address (RAM, ROM & #`
371			`# Peripherals. #`
372	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
373			`# Format - 0 to write a word, 1 to write a byte. #`
374	2	olivier.gi	`# Addr - Destination address for data to be written. #`
375			`# Data - Data value to be written. #`
376			`# Result : 0 if error, 1 otherwise. #`
377			`#=============================================================================#`
378	158	olivier.gi	`proc WriteMem {CpuNr Format Addr Data} {`
379	2	olivier.gi
380	158	olivier.gi	`global omsp_conf`
381	2	olivier.gi
382	158	olivier.gi	`# Copy global variable to local for code readability`
383			`set if $omsp_conf(interface)`
384			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
385
386			`# Configure memory transfer`
387			`#${if}::dbg_wr $cpuaddr MEM_CNT 0x0000`
388			`${if}::dbg_wr $cpuaddr MEM_ADDR $Addr`
389			`${if}::dbg_wr $cpuaddr MEM_DATA $Data`
390
391			`# Trigger transfer`
392	2	olivier.gi	`if {$Format==0} {`
393	158	olivier.gi	`${if}::dbg_wr $cpuaddr MEM_CTL 0x0003`
394	2	olivier.gi	`} else {`
395	158	olivier.gi	`${if}::dbg_wr $cpuaddr MEM_CTL 0x000b`
396	2	olivier.gi	`}`
397
398			`return 1`
399			`}`
400
401			`#=============================================================================#`
402	158	olivier.gi	`# WriteMemQuick (CpuNr, StartAddr, DataList) #`
403	2	olivier.gi	`#-----------------------------------------------------------------------------#`
404	158	olivier.gi	`# Description: Writes a list of words into the target device memory (RAM, #`
405	2	olivier.gi	`# ROM & Peripherals. #`
406	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
407			`# StartAddr - Start address of destination memory. #`
408			`# DataList - List of data to be written (in hexadecimal). #`
409	2	olivier.gi	`# Result : 0 if error, 1 otherwise. #`
410			`#=============================================================================#`
411	158	olivier.gi	`proc WriteMemQuick {CpuNr StartAddr DataList} {`
412	2	olivier.gi
413	158	olivier.gi	`global omsp_conf`
414
415			`# Copy global variable to local for code readability`
416			`set if $omsp_conf(interface)`
417			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
418
419			`# Single data transfer`
420			`if {[llength $DataList]==1} {`
421			`WriteMem $CpuNr 0 $StartAddr $DataList`
422
423			`# Burst data transfer`
424	2	olivier.gi	`} else {`
425
426	158	olivier.gi	`# Configure & trigger memory transfer`
427			`${if}::dbg_wr $cpuaddr MEM_CNT [expr [llength $DataList]-1]`
428			`${if}::dbg_wr $cpuaddr MEM_ADDR $StartAddr`
429			`${if}::dbg_wr $cpuaddr MEM_CTL 0x0003`
430	2	olivier.gi
431	158	olivier.gi	`# Send data list`
432			`${if}::dbg_burst_tx $cpuaddr 0 $DataList`
433	2	olivier.gi
434			`}`
435			`return 1`
436			`}`
437
438			`#=============================================================================#`
439	158	olivier.gi	`# ReadMem (CpuNr, Format, Addr) #`
440	2	olivier.gi	`#-----------------------------------------------------------------------------#`
441			`# Description: Read one byte or word from a specified target memory address. #`
442	158	olivier.gi	`# Arguments : CpuNr - oMSP device number to be addressed. #`
443			`# Format - 0 to read a word, 1 to read a byte. #`
444	2	olivier.gi	`# Addr - Target address for data to be read. #`
445			`# Result : Data value stored in the target address memory location. #`
446			`#=============================================================================#`
447	158	olivier.gi	`proc ReadMem {CpuNr Format Addr} {`
448	2	olivier.gi
449	158	olivier.gi	`global omsp_conf`
450	2	olivier.gi
451	158	olivier.gi	`# Copy global variable to local for code readability`
452			`set if $omsp_conf(interface)`
453			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
454
455			`# Single data transfer`
456			`#${if}::dbg_wr $cpuaddr MEM_CNT 0x0000`
457			`${if}::dbg_wr $cpuaddr MEM_ADDR $Addr`
458
459			`# Trigger transfer`
460	2	olivier.gi	`if {$Format==0} {`
461	158	olivier.gi	`${if}::dbg_wr $cpuaddr MEM_CTL 0x0001`
462			`set mem_val [${if}::dbg_rd $cpuaddr MEM_DATA]`
463	2	olivier.gi	`} else {`
464	158	olivier.gi	`${if}::dbg_wr $cpuaddr MEM_CTL 0x0009`
465			`set mem_val [${if}::dbg_rd $cpuaddr MEM_DATA]`
466			`set mem_val [format "0x%02x" $mem_val]`
467	2	olivier.gi	`}`
468
469			`return $mem_val`
470			`}`
471
472			`#=============================================================================#`
473	158	olivier.gi	`# ReadMemQuick (CpuNr, StartAddr, Length) #`
474	2	olivier.gi	`#-----------------------------------------------------------------------------#`
475	158	olivier.gi	`# Description: Reads a list of words from target memory. #`
476			`# Arguments : CpuNr - oMSP device number to be addressed. #`
477			`# StartAddr - Start address of target memory to be read. #`
478			`# Length - Number of words to be read. #`
479	2	olivier.gi	`# Result : List of data values stored in the target memory. #`
480			`#=============================================================================#`
481	158	olivier.gi	`proc ReadMemQuick {CpuNr StartAddr Length} {`
482	2	olivier.gi
483	158	olivier.gi	`global omsp_conf`
484
485			`# Copy global variable to local for code readability`
486			`set if $omsp_conf(interface)`
487			`set cpuaddr $omsp_conf($CpuNr,cpuaddr)`
488
489			`# Single data transfer`
490	2	olivier.gi	`if {$Length==1} {`
491	158	olivier.gi	`set mem_val [ReadMem $CpuNr 0 $StartAddr]`
492
493			`# Burst data transfer`
494	2	olivier.gi	`} else {`
495
496	158	olivier.gi	`# Configure & trigger memory transfer`
497			`${if}::dbg_wr $cpuaddr MEM_CNT [expr $Length-1]`
498			`${if}::dbg_wr $cpuaddr MEM_ADDR $StartAddr`
499			`${if}::dbg_wr $cpuaddr MEM_CTL 0x0001`
500	2	olivier.gi

Browse

Tools

Subversion Repositories openmsp430

[/] [openmsp430/] [trunk/] [tools/] [lib/] [tcl-lib/] [dbg_functions.tcl] - Blame information for rev 203