MEM.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "MEM related mnemonics"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/03/31 05:02:30 $"
__version__  = "$Revision: 1.13 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import struct
import time
import logging as log

from LICOS.lib.cmdTlmDb.cmdTlmDb import CmdPkg
from LICOS.lib.LATconstants import *
from LICOS.lib.cmdTlmDb.TelemetryEvent import TelemetryEvent

# boot modes
MEMTOOL_MODE_PBC  = 0
MEMTOOL_MODE_SBC  = 1

DUMP_MNEMONICS = { FSW_UNIT_SIU : [ "LBTHKP",      "LMEMSIUDATA"  ],
                   FSW_UNIT_EPU0: [ "LBTEPU0HKP",  "LMEMEPU0DATA" ],
                   FSW_UNIT_EPU1: [ "LBTEPU1HKP",  "LMEMEPU1DATA" ],
                   FSW_UNIT_EPU2: [ "LBTEPU2HKP",  "LMEMEPU2DATA" ],
                   }
DUMP_TLM_INFIX = { FSW_UNIT_SIU : [ "MEM",  "SIU"  ],
                   FSW_UNIT_EPU0: [ "0",    "EPU0" ],
                   FSW_UNIT_EPU1: [ "1",    "EPU1" ],
                   FSW_UNIT_EPU2: [ "2",    "EPU2" ],
                   }
DUMP_POOL_MNEMS = ['LMEMTPOOLLATUNIT', 'LMEMTPOOLTRANID', 'LMEMTPOOLID', 'LMEMTPOOLFREBYT',
                   'LMEMTPOOLFREBLK', 'LMEMTPOOLMAXBLK', 'LMEMTPOOLALCBYT', 'LMEMTPOOLALCBLK' ]

MEM_LOAD_FRAG_SIZE = 11


class MEM(CmdPkg):
  """!\brief MEM telecommand package class

  Provides access to MEM telecommands.
  """
  def __init__(self, db):
    """!\brief MEM constructor.

    \param db  Wrapper database object for the generated module
              containing command and telemetry database classes.
    """
    CmdPkg.__init__(self, db)
    self.__primaryBoot=False

  def dumpMemory(self, unit, address, size, tranID, dest):
    """!\brief Dump a region of memory

    \param unit        LAT unit id to download
    \param address     starting address
    \param size        number of 32-bit words to dump
    \param tranid      transaction id
    \param dest        Memory dump destination (FSW_DEST_1553 or FSW_DEST_SSR)

    \return            Dumped memory value as packed string
    """

    try:
      md = self.DumpTool(self.getCmdDb(), unit, self.__primaryBoot)
      memory = md.dumpMemory(address, size, tranID, dest)
    except Exception, e:
      log.exception(e)
      memory = None
    return memory

  def loadMemory(self, unit, address, tranID, data):
    """!\brief Load data to a region of memory

    \param unit        LAT unit id to download
    \param address     Starting address
    \param tranid      Transaction id
    \param data        Packed string of 32-bit words to load

    \return            True if memory load was successful, False otherwise
    """

    try:
      ml = self.LoadTool(self.getCmdDb(), unit, self.__primaryBoot)
      status = ml.loadMemory(address, tranID, data)
    except Exception, e:
      log.exception(e)
      status = False
    return status

  def dumpPool(self, unit, tranID, poolID):
    dumpHdlr = TelemetryEvent(cmdDb.getVsc().getDiagHandler(),
                              [ cmdDb.getVsc().getTlmDb().getApidFromName('LMEMPOOLDATA')] )
    dumpHdlr.enable()
    self.LMEMDUMPPOOL( LMEMLATUNIT = unit,
                                LMEMTRANID  = tranID,
                                LMEMPOOLID  = poolID)
    status = self.__checkLastCommandStatus()

    plds = dumpHdlr.waitForPayload( DUMP_POOL_MNEMS, timeout = LONG_TIMEOUT )
    dumpHdlr.disable()

    return plds

  def dumpSymbol(self, unit, tranID, name):

    mnemDict = {}
    for i in xrange(48):
      mnem = 'LMEMNAME%02d' % i
      if i < len(name):
        mnemDict[mnem] = ord(name[i])
      else:
        mnemDict[mnem] = 0

    dumpHdlr = TelemetryEvent(cmdDb.getVsc().getDiagHandler(),
                              [ cmdDb.getVsc().getTlmDb().getApidFromName('LMEMSYMVAL')] )
    symMnems = ['LMEMTSYMNAME%02d' % i for i in xrange(48)]

    plds     = ['LMEMTSYMLATUNIT', 'LMEMTSYMTRANID', 'LMEMTSYMVALUE', 'LMEMTSYMNAMESIZE'] + \
               symMnems

    dumpHdlr.enable()
    self.LMEMDUMPSYMVAL( LMEMLATUNIT  = unit,
                         LMEMTRANID   = tranID,
                         LMEMNAMESIZE = len(name),
                         LMEMPAD      = 0,
                         **mnemDict)
    status = self.__checkLastCommandStatus()

    plds = dumpHdlr.waitForPayload( plds, timeout = LONG_TIMEOUT )
    dumpHdlr.disable()

    if plds is None:   # timed out?
      return plds

    siz      = plds[3]
    symName  = ''.join(map(chr, plds[4:4+siz]))

    return plds[0:3] + [symName]

  def dumpPCI(self, unit, tranID, bus, device, function):
    try:
      md = self.DumpTool(self.getCmdDb(), unit, self.__primaryBoot)
      memory = md.dumpPCIheader(bus, device, function, tranID)
    except Exception, e:
      log.exception(e)
      memory = None
    return memory


  def cancelDumpMemory(self, unit, tranID):
    self.LMEMDUMPCANCEL( LMEMLATUNIT  = unit,
                         LMEMTRANID   = tranID)
    status = self.__checkLastCommandStatus()
    return status

  def getPoolStatus(self, unit, tranID, poolID):
    # alternate interface to LMEMDUMPPOOL
    return self.dumpPool(unit, tranID, poolID)

  def __checkLastCommandStatus(self):
    # boilerplate code that waits for completion on a command
    #   and checks the completion status.  If bad, log a warning
    status = True
    if self.__primaryBoot:
      log.warn("Command completion disabled")
      import time
      time.sleep(1)
      return status
    app = self.getCmdDb()
    status = app.waitForConfirmation(timeout = LONG_TIMEOUT)
    statusMsg = app.getConfirmationMsg()
    if not app.getVsc().getTlmDb().msgIsSuccess(statusMsg):
      log.warning(app.getVsc().getTlmDb().msgByValue(statusMsg))
      status=False
    return status

  def setPrimaryBoot(self, bool):
    self.__primaryBoot = bool


  ##private
  class DumpTool(object):
    """!\brief Provide a private memory dumping class for fileTools.py
    """
    def __init__(self, cmdDb, unit, primaryBoot):
      self.__cmdDb = cmdDb
      self.__unit  = unit
      self.__primaryBoot = primaryBoot
      self.__frags = {}  # cache of dump fragments, keyed by memory loc
      self.__sizes = {}  # sizes of above, same keys
      self.__mode  = None
      self.__tlms = [ cmdDb.getVsc().getTlmDb().getApidFromName(n) for n in DUMP_MNEMONICS[unit] ]
      # 2 dump handlers because some telem can come back on telemetry line
      self.__dumpHdlr = TelemetryEvent(cmdDb.getVsc().getDiagHandler(),
                                       self.__tlms, self.dumpMem)
      self.__dumpHdlr2 = TelemetryEvent(cmdDb.getVsc().getTelemHandler(),
                                        self.__tlms, self.dumpMem)

    def dumpMem(self, telemetry):
      packet = self.__cmdDb.getVsc().getTlmDb().decodeTelemetry(telemetry)
      self.__mode = DUMP_MNEMONICS[self.__unit].index(packet.name)
      if self.__mode == 0:
        self.__parsePBC(packet)
      elif self.__mode == 1:
        self.__parseSBC(packet)
      else:
        raise "MemDump Can't Get To This Line"

    def __parsePBC(self, packet):
      mode = 0
      infix =  DUMP_TLM_INFIX[self.__unit][mode]
      pktStart = packet.get_payload( 'LPBC%sDUMPADDR' % infix )
      pktWords = packet.get_payload( 'LPBC%sDUMPWC' % infix )

      # For SIU payload is LPBCMEMDUMPDATxx,
      # for EPUs it is LPBCiDUMPDATAxx
      if self.__unit == FSW_UNIT_SIU:
        suffix = ""
      else:
        suffix = "A"

      # Primary boot telemetry comes out *constantly*  we must *check*
      if self.__address <= pktStart < self.__address+self.__size*4:
        dataMnems = [ 'LPBC%sDUMPDAT%s%02d' % (infix, suffix, i) for i in range(pktWords) ]
        dataStrs  = [ struct.pack('!I', datum) for datum in map(packet.get_payload, dataMnems) ]
        self.__frags[pktStart] = ''.join(dataStrs)
        self.__sizes[pktStart] = pktWords


    def __parseSBC(self, packet):
      mode = 1
      infix =  DUMP_TLM_INFIX[self.__unit][mode]
      pktStart = packet.get_payload( 'LMEMT%sADDRESS' % infix )
      pktWords = packet.get_payload( 'LMEMT%sWORDCNT' % infix )

      dataMnems = [ 'LMEMT%sDATA%d' % (infix, i) for i in range(pktWords) ]
      dataStrs  = [ struct.pack('!I', datum) for datum in map(packet.get_payload, dataMnems) ]
      self.__frags[pktStart] = ''.join(dataStrs)
      self.__sizes[pktStart] = pktWords


    def __retrieveData(self, size):
      # wait until we have everything, or timeout in LONG_TIMEOUT
      n = 0
      lastSum = 0
      while n < STANDARD_TIMEOUT:
        s = sum(self.__sizes.values())
        if s > lastSum:
          lastSum = s
          n = 0
        if s >= size: break
        time.sleep(1)
        n += 1

      memLocs = self.__frags.keys()
      memLocs.sort()
      memory = ''
      for item in memLocs:
        memory += self.__frags[item]
      return memory

    def dumpMemory(self, address, size, tranID, dest):
      # mem dump telecommand wants ushorts
      address_lo = address & 0x0000ffff
      size_lo    = size    & 0x0000ffff
      address_hi = address >> 16
      size_hi    = size    >> 16

      self.__address = address
      self.__size    = size

      self.__dumpHdlr.enable()
      self.__dumpHdlr2.enable()
      self.__cmdDb.MEM.LMEMDUMPMEM( LMEMLATUNIT   = self.__unit,
                                    LMEMTRANID    = tranID,
                                    LMEMDEST      = dest,
                                    LMEMPAD       = 0,
                                    LMEMADDRESSHI = address_hi,
                                    LMEMADDRESSLO = address_lo,
                                    LMEMSIZEHI    = size_hi,
                                    LMEMSIZELO    = size_lo)
      #JHP: remove command conf as this won't work in primary boot
      if not self.__primaryBoot:
        if not self.__cmdDb.waitForSuccessfulConfirmation():
          result = False
      memory = self.__retrieveData(size)
      self.__dumpHdlr.disable()
      self.__dumpHdlr2.disable()
      return memory

    def dumpPCIheader(self, bus, device, function, tranID):
      #
      pciHdrSize  = 64
      self.__dumpHdlr.enable()
      self.__cmdDb.MEM.LMEMDUMPPCI( LMEMLATUNIT     = self.__unit,
                                    LMEMTRANID      = tranID,
                                    LMEMPCIBUS      = bus,
                                    LMEMPCIDEVICE   = device,
                                    LMEMPCIFUNCTION = function,
                                    LMEMPAD         = 0)
      #JHP: remove command conf as this won't work in primary boot
      if not self.__primaryBoot:
        if not self.__cmdDb.waitForSuccessfulConfirmation():
          result = False
      header = self.__retrieveData(pciHdrSize)
      self.__dumpHdlr.disable()

      return header

  class LoadTool(object):
    """!\brief Provide a private memory dumping class for fileTools.py
    """
    def __init__(self, cmdDb, unit, primaryBoot):
      """!\brief LoadTool constructor.

      \param cmdDb       Command database
      \param unit        LAT unit id to load
      \param primaryBoot Flag indicating whether the unit is in primary boot or not
      """
      self.__cmdDb = cmdDb
      self.__unit  = unit
      self.__primaryBoot = primaryBoot

    def loadMemory(self, address, tranID, data):
      """!\brief Load a given memory address with data.

      \param address Starting address
      \param tranID  Transaction ID
      \param data    Packed string of 32-bit words to load

      \return        True if the load was successful, False otherwise.
      """
      result = True

      offset = 0

      size = len(data)

      if size % 4 != 0:
        raise ValueError, "Load memory data size has to be a multiple of 4"

      while offset < size:

        address_lo = (address + offset) & 0x0000ffff
        address_hi = (address + offset) >> 16

        if (size - offset) / 4 > MEM_LOAD_FRAG_SIZE:
          loadSize = MEM_LOAD_FRAG_SIZE
        else:
          loadSize = (size - offset) / 4

        dataFragments = ()
        for i in range(MEM_LOAD_FRAG_SIZE):
          if i < loadSize:
            datum = struct.unpack('!I', data[offset+(i<<2):offset+((i+1)<<2)])[0]
            data_hi = datum >> 16
            data_lo = datum & 0x0000ffff
          else:
            data_hi = 0
            data_lo = 0

          dataFragments += (data_hi, data_lo)

        self.__cmdDb.MEM.LMEMLOADMEM(self.__unit,
                                    tranID,
                                    loadSize,
                                    address_hi,
                                    address_lo,
                                    *dataFragments)
        if not self.__primaryBoot:
          if not self.__cmdDb.waitForSuccessfulConfirmation():
            result = False
            break
        offset += loadSize*4
      return result

---