Subversion Repositories openmsp430

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

# 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: 210 $

# $LastChangedBy: olivier.girard $

# $LastChangedDate: 2015-11-17 10:57:08 +0100 (Tue, 17 Nov 2015) $

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

#

# 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]} {

            utils::uart_close

            return 0

        }

        # Make sure the CPU_ID is correct

        if {![VerifyCPU_ID $CpuNr]} {

            utils::uart_close

            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]]

    }

    # Close serial connection

    utils::uart_close

    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)                                                        #

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