rvdebug.stp

realview22.rar

  # built up from other registers. This allows extracting of specific
  # bits from other registers defined here to create a single register.
  # Concatenation registers are usually only used for memory mapping,
  # but can be used for control and status as well. The approach is to
  # name two registers and then shift and mask them into the new register.
  # If more than two registers are needed, you can build up.
  {Concat_Reg*ister     \\ Definition of concatenated registers.
    # 140 ; 
    low_name=S          \\ name of low register
    # 289 ; 
    low_shift=V0x00        \\ amount to shift low register by (<0 for left shift)
    # 155 ; 
    low_mask=V0x00000000    \\ amount to mask (after shift) of low register
    # 319 ; 
    high_name=S         \\ name of high register
    # 304 ; 
    high_shift=V0x00000000     \\ amount to shift high register by (<0 for left shift)
    # 139 ; 
    high_mask=V0x00000000\\ amount to mask (after shift) of high register
    # 181 ; 
    l*ength=V(1-4)4     \\ Length (in memory units) of register.
    # 260 ; The register type field is used to define an explicit type for the
    # the register. If one is not specified, the default is the signed
    # scalar C type based on the register size.
    *type=K(s*igned,u*nsigned,p*ointer,f*loat,d*ouble,l*abel)0 \
                        \\ Type of register.
    # 154 ; 
    enum=K($TEMPL_GROUP=Register_enum.)\\ Name of Register_enum to show values with
    # 196 ; 
    gui_name=S          \\ Optional name for showing in register window.
  }
  # 195 ; Peripheral Definition is used to define block peripherals so they may
  # be mapped in memory (for display and control) as well as accessed for
  # block data (when available). The perhiperhal is defined in terms of
  # the area of memory it occupies (for all its registers) and then a
  # breakdown of the registers used for access and control.
  {Per*ipherals         \\ Definition of peripherals.
    # 153 ; 
    start=V             \\ Start adddress of first peripheral register.
    # 152 ; 
    length=V            \\ Block length.
    # 172 ; The base field controls how the start field is interpreted.
    # The default is Absolute (from 0), but can be relative to a
    # memory block (if the block is disabled, the peripheral is too).
    base=K(Absolute,$TEMPL_GROUP=Memory_block.)0 \\ Start address base
    # 277 ; 
    type=K(serial,parallel,block,network,display,\
        other)          \\ Basic type of perhiperal device.
    # 276 ; 
    description=S       \\ Description of device.
    # 138 ; 
    {.Access_Method     \\ Used when can access blocks of data.
      # 241 ; 
      type=K(buffer,DMA,polled,other) \\ Method used to extract data.
      # 252 ; 
      method_name=N     \\ Name of access method function if needed.
      # 313 ; 
      start=V           \\ Buffer/DMA start address.
      # 194 ; 
      length=V          \\ Buffer/DMA length.
    }
    # 193 ; Register Definition is used to add memory mapped registers provided
    # at the board or ASIC level. Each register is named and typed and may
    # be sub-divided into bit-fields (any number of bits) which act as
    # sub-registers.
    {Reg*ister          \\ Definition of Memory mapped registers.
      # 231 ; 
      *start=V          \\ Start address of register (in memory units).
      # 220 ; 
      l*ength=V(1-4)1   \\ Length (in memory units) of register.
      # 259 ; The base field controls how the start field is interpreted.
      # The default is Absolute (from 0), but can be relative to the
      # peripheral start or a memory block (if the block is disabled, 
      # the register is too).
      base=K(Absolute,Peripheral_start,$TEMPL_GROUP=Memory_block.)0 \\ Start address base
      # 258 ; The type of memory indicates where the register memory comes from
      # on processors that have multiple spaces. Default is mapped to data 
      # space.
      memory_type=K(def*ault,prog*ram,dat*a,IO)0 \\ Type of memory space
      # 171 ; The register type field is used to define an explicit type for the
      # the register. If one is not specified, the default is the signed
      # scalar C type based on the register size.
      *type=K(s*igned,u*nsigned,p*ointer,f*loat,d*ouble,l*abel)0 \
                          \\ Type of register.
      # 288 ; 
      read_only=B0      \\ True if read-only register.
      # 219 ; 
      write_only=B0     \\ True if write-only register.
      # 287 ; Volatility indicates that the register has side-effects when accessed
      # (read or write). Common read side-effects are the data is lost (such
      # as pulled from a UART). Common write side-effects are the device 
      # takes some action on write (such as triggers a DMA). This information
      # is used in the register window.
      volatile=K(normal,on_read,on_write,on_both)0 \\ Volatility of register \
                        \K Not Volatile,Contents altered on Read,\
                           Side effect to Write,Side effect to any Access
      # 251 ; 
      enum=K($TEMPL_GROUP=Register_enum.)\\ Name of Register_enum to show values with
      # 240 ; 
      gui_name=S                \\ Optional name for showing in register window.
      # 303 ; 
      {bit*_fields      \\ Bit Fields within a Register.
        # 302 ; 
        pos*ition=V(0-32)0\\ Bit position from 0 (LSbit).
        # 239 ; 
        size=V(1-32)1   \\ Size in bits.
        # 250 ; 
        signed=B0               \\ True if signed vs. unsigned.
        # 218 ; 
        enum=K($TEMPL_GROUP=Register_enum.)\\ Name of Register_enumeration to show values with
        # 137 ; 
        read_only=B0    \\ True if read-only (cannot modify).
        # 238 ; Volatility indicates that the register has side-effects when accessed
        # (read or write). Common read side-effects are the data is lost (such
        # as pulled from a UART). Common write side-effects are the device 
        # takes some action on write (such as triggers a DMA). This information
        # is used in the register window.
        volatile=K(normal,on_read,on_write,on_both)0 \\ Volatility of register \
                          \K Not Volatile,Contents altered on Read,\
                             Side effect to Write,Side effect to any Access
        # 192 ; 
        gui_name=S      \\ Optional name for showing in register window.
      }
    }
  }
  # 217 ; The Register_Window entry contains a set of lines to show in the
  # the register window. The name of the block will be the tab name used
  # for the lines. Each line contains a list of mapped registers
  # (defined above) to show. The format of a line is name,name,name where
  # each "name" is the name of a register or bit field. If the string 
  # starts with an "=" character, all the registers will be shown as 
  # name=value in the window, else it will show in table form (the name
  # is above the value). If a line starts with an "_" character, the 
  # line will show as a comment label (non-active). If the line starts
  # with an "!" character, it provides a description line for the tab.
  # If the line starts with $, the next line will start or end an expansion
  # block (controlled by +/- icon). If $+, it is a collapsed block. If $-,
  # it is an expanded block. If $$, it ends a previously opened block.
  {Register_Window      \\ Register window format details
    # 275 ; 
    line=LS             \\ Name of registers to show on one line (name,name,...)
  }
  # 136 ; The ARM_config block allows control of ARM processor use for
  # ARM Ltd emulators/monitors/simulators and Allant VIA emulators.
  # These control features such as semi-hosting, vector catching,
  # memory top control (for stack/heap assignment), etc. These need
  # to be set or unset depending on the type of run-time you have
  # linked into your application. Note that many of these can be
  # set at runtime as well via pseudo-registers. To use this, you
  # should name the block "default" for all devices or else the
  # device name in the chain to affect.
  {$ARM_config          \\ Configuration for ARM processor use
    # 168 ; Top_memory is used to allow the semi-hosting mechanism to
    # return the top of stack and base of heap. If not defined
    # here, the default for each tool is used (different among
    # Angel, EmbeddedICE, ARMulator). If defined, that will be
    # set into each tool to force this address base. Note that
    # you can use explicit stack/heap sizes and locations below
    # but this may not be supportable among all systems. Note
    # that you can set this during a debug session using the
    # @top_mem pseudo register.
    top_memory=V        \\ Set top of memory for stack/heap use.
    # 229 ; The ARM Ltd tools model is to automatically set the stack
    # and heap based on top_memory using semi-hosting. This is 
    # not always desirable. You can link in 4 symbols that point
    # to the base/end of stack and heap to get around this. The 
    # symbols are called __heap_base/__heap_limit and 
    # __stack_base and __stack_limit and are each pointers to
    # start/end. For VIA emulators, you can also specify the 
    # stack and heap base/end values here and they will be 
    # provided during semi-hosting. You must specify at least
    # a heap base for this to be used.
    {.Stack_Heap        \\ Set Stack and Heap specifically (VIA only)
    # 150 ; 
      stack_bottom=V<above heap>\\ bottom of stack (lowest address)
    # 318 ; 
      stack_size=V0x2000 \\ size of stack in bytes.
    # 228 ; 
      heap_base=V       \\ bottom of heap (lowest address)
    # 237 ; 
      heap_size=V0x4000 \\ size of heap in bytes.
    }
    # 265 ; Vector_catching is used to catch possible program errors
    # by setting breakpoints on (or otherwise trapping) the 
    # vectors. The default is to catch error-type vectors but
    # leave IRQ/FIQ and SWI alone. Note that SWI will be caught
    # separately by semi-hosting if enabled. To use this, the
    # vectors must be writable. These can also be set during
    # debugging using the @vector_catch pseudo register. In 
    # that case, each bit (starting with 1) represents the 
    # vectors from reset to FIQ.
    vector_catch=B1     \\ True if should have vector catching
    # 149 ; If vector_catch is True, the fields within this block allow
    # individual control over each vector.
    {.Vectors           \\ defines state of individual vectors for catching
      # 298 ; 
      Reset=B1          \\ True if should catch Reset vector
      # 210 ; 
      Undefined=B1      \\ True if should catch Undefined Instructions
      # 145 ; 
      SWI=B0            \\ True if should catch Software Interrupts
      # 209 ; 
      P_Abort=B1        \\ True if should catch Prefetch Aborts
      # 144 ; 
      D_Abort=B1        \\ True if should catch Data Aborts
      # 188 ; 
      Address=B1        \\ True if should catch Address Exceptions
      # 178 ; 
      IRQ=B0            \\ True if should catch IRQ interrupts
      # 248 ; 
      FIQ=B0            \\ True if should catch FIQ interrupts
      # 234 ; 
      Error=B1          \\ True if should catch Errors
    }
    # 151 ; Semi-hosting allows the ARM Ltd compiler tools runtime to
    # communicate with the host. The base semi-hosting operations
    # supported are stack/heap assignment and console I/O (printf
    # and scanf type calls). Semi-hosting is supported by having
    # the application code perform an SWI instruction with a specific
    # pattern (default is 0x123456). Note that you can change the
    # semi-hosting vector during debug using the @semihost_vector
    # pseudo register. You can also define a window number to
    # send semi-hosting printf messages using @semihost_window.
    # The window numbers match the VOPEN command's numbers.
    {.Semihosting
      # 180 ;
      enabled=B1        \\ True if should support semi-hosting calls
      # 274 ;