Subversion Repositories w11

// $Id: RlinkCommand.cpp 495 2013-03-06 17:13:48Z mueller $
//
// Copyright 2011-2013 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
// This program is free software; you may redistribute and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 2, or at your option any later version.
//
// This program 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 General Public License
// for complete details.
// 
// Revision History: 
// Date         Rev Version  Comment
// 2013-05-06   495   1.0.2  add RlinkContext to Print() args
// 2013-02-03   481   1.0.1  use Rexception
// 2011-03-27   374   1.0    Initial version
// 2011-01-15   355   0.1    First draft
// ---------------------------------------------------------------------------
 
/*!
  \file
  \version $Id: RlinkCommand.cpp 495 2013-03-06 17:13:48Z mueller $
  \brief   Implemenation of class RlinkCommand.
 */
 
// debug
#include <iostream>
 
#include <algorithm>
 
#include "RlinkCommand.hpp"
 
#include "librtools/RosFill.hpp"
#include "librtools/RosPrintf.hpp"
#include "librtools/RosPrintBvi.hpp"
#include "librtools/Rexception.hpp"
 
using namespace std;
 
/*!
  \class Retro::RlinkCommand
  \brief FIXME_docs
*/
 
// all method definitions in namespace Retro
namespace Retro {
 
//------------------------------------------+-----------------------------------
// constants definitions
 
const uint8_t  RlinkCommand::kCmdRreg;
const uint8_t  RlinkCommand::kCmdRblk;
const uint8_t  RlinkCommand::kCmdWreg;
const uint8_t  RlinkCommand::kCmdWblk;
const uint8_t  RlinkCommand::kCmdStat;
const uint8_t  RlinkCommand::kCmdAttn;
const uint8_t  RlinkCommand::kCmdInit;
 
const uint32_t RlinkCommand::kFlagInit;
const uint32_t RlinkCommand::kFlagSend;
const uint32_t RlinkCommand::kFlagDone;
const uint32_t RlinkCommand::kFlagPktBeg;
const uint32_t RlinkCommand::kFlagPktEnd;
const uint32_t RlinkCommand::kFlagRecov;
const uint32_t RlinkCommand::kFlagResend;
const uint32_t RlinkCommand::kFlagErrNak;
const uint32_t RlinkCommand::kFlagErrMiss;
const uint32_t RlinkCommand::kFlagErrCmd;
const uint32_t RlinkCommand::kFlagErrCrc;
const uint32_t RlinkCommand::kFlagChkStat;
const uint32_t RlinkCommand::kFlagChkData;
const uint32_t RlinkCommand::kFlagVol;
 
const uint8_t RlinkCommand::kStat_M_Stat;
const uint8_t RlinkCommand::kStat_V_Stat;
const uint8_t RlinkCommand::kStat_B_Stat;
const uint8_t RlinkCommand::kStat_M_Attn;
const uint8_t RlinkCommand::kStat_M_Cerr;
const uint8_t RlinkCommand::kStat_M_Derr;
const uint8_t RlinkCommand::kStat_M_RbNak;
const uint8_t RlinkCommand::kStat_M_RbErr;
 
const uint16_t RlinkCommand::kRbaddr_IInt;
const uint16_t RlinkCommand::kIInt_M_AnEna;
const uint16_t RlinkCommand::kIInt_M_ItoEna;
const uint16_t RlinkCommand::kIInt_M_ItoVal;
 
//------------------------------------------+-----------------------------------
//! Default constructor
 
RlinkCommand::RlinkCommand()
  : fRequest(0), 
    fAddress(0), 
    fData(0),
    fBlock(),
    fpBlockExt(0), 
    fBlockExtSize(0), 
    fStatRequest(0), 
    fStatus(0), 
    fFlags(0),
    fRcvSize(0),
    fpExpect(0)
{}
 
//------------------------------------------+-----------------------------------
//! Copy constructor
 
RlinkCommand::RlinkCommand(const RlinkCommand& rhs)
  : fRequest(rhs.fRequest), 
    fAddress(rhs.fAddress), 
    fData(rhs.fData),
    fBlock(rhs.fBlock),
    fpBlockExt(rhs.fpBlockExt), 
    fBlockExtSize(rhs.fBlockExtSize), 
    fStatRequest(rhs.fStatRequest), 
    fStatus(rhs.fStatus), 
    fFlags(rhs.fFlags),
    fRcvSize(rhs.fRcvSize),
    fpExpect(rhs.fpExpect ? new RlinkCommandExpect(*rhs.fpExpect) : 0)
{}
 
//------------------------------------------+-----------------------------------
//! Destructor
 
RlinkCommand::~RlinkCommand()
{
  delete fpExpect;                          // expect object owned by command
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::CmdRblk(uint16_t addr, size_t size)
{
  SetCommand(kCmdRblk, addr);
  SetBlockRead(size);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::CmdRblk(uint16_t addr, uint16_t* pblock, size_t size)
{
  SetCommand(kCmdRblk, addr);
  SetBlockExt(pblock, size);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::CmdWblk(uint16_t addr, const std::vector<uint16_t>& block)
{
  SetCommand(kCmdWblk, addr);
  SetBlockWrite(block);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::CmdWblk(uint16_t addr, const uint16_t* pblock, size_t size)
{
  SetCommand(kCmdWblk, addr);
  SetBlockExt(const_cast<uint16_t*>(pblock), size);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::SetCommand(uint8_t cmd, uint16_t addr, uint16_t data)
{
  if (cmd > kCmdInit) 
    throw Rexception("RlinkCommand::SetCommand()", "Bad args: invalid cmd");
  if (addr > 0xff) 
    throw Rexception("RlinkCommand::SetCommand()", "Bad args: invalid addr");
  fRequest = cmd;
  fAddress = addr;
  fData    = data;
  fpBlockExt    = 0;
  fBlockExtSize = 0;
  fStatus  = 0;
  fFlags   = kFlagInit;
  fRcvSize = 0;
  delete fpExpect;
  fpExpect = 0;
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::SetAddress(uint16_t addr)
{
  if (addr > 0xff) 
    throw Rexception("RlinkCommand::SetAddress()", "Bad args: invalid addr");
  fAddress = addr;
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::SetBlockWrite(const std::vector<uint16_t>& block)
{
  if (block.size() == 0 || block.size() > 256) 
    throw Rexception("RlinkCommand::SetBlockWrite()",
                     "Bad args: invalid block size");
  fBlock = block;
  fpBlockExt    = 0;
  fBlockExtSize = 0;
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::SetBlockRead(size_t size)
{
  if (size == 0 || size > 256) 
    throw Rexception("RlinkCommand::SetBlockRead()",
                     "Bad args: invalid block size");
  fBlock.clear();
  fBlock.resize(size);
  fpBlockExt    = 0;
  fBlockExtSize = 0;
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::SetBlockExt(uint16_t* pblock, size_t size)
{
  if (pblock == 0) 
    throw Rexception("RlinkCommand::SetBlockExt()",
                     "Bad args: pblock is null");
  if (size == 0 || size > 256) 
    throw Rexception("RlinkCommand::SetBlockExt()",
                     "Bad args: invalid block size");
  fpBlockExt    = pblock;
  fBlockExtSize = size;
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::SetExpect(RlinkCommandExpect* pexp)
{
  delete fpExpect;
  fpExpect = pexp;
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::Print(std::ostream& os, const RlinkContext& cntx,
                         const RlinkAddrMap* pamap, size_t abase, 
                         size_t dbase, size_t sbase) const
{
  uint8_t ccode = Command();
 
  // separator + command mnemonic, code and flags
  // separator:  ++  first in packet
  //             --  non-first in packet
  //             -=  non-first in packet (marked volatile)
  const char* sep = "??";
  if (TestFlagAny(kFlagPktBeg)) {
    sep = "++";
  } else {
    sep = TestFlagAny(kFlagVol) ? "-=" : "--";
  }
 
  os << sep << " " << CommandName(ccode)
     << " (" << RosPrintBvi(Request(), 8)
     << ","  << RosPrintBvi(fFlags, 16, 20)
     << ")";
 
  // address field
  if (ccode==kCmdRreg || ccode==kCmdRblk ||
      ccode==kCmdWreg || ccode==kCmdWblk ||
      ccode==kCmdInit) {
    os << " a=" << RosPrintBvi(fAddress, abase);
    if (pamap) {
      string name;
      if (!pamap->Find(fAddress, name)) name.clear();
      os << "(" << name << RosFill(pamap->MaxNameLength()-name.length()) << ")";
    }
  }
 
  // data field (scalar)
  if (ccode== kCmdRreg || ccode==kCmdWreg ||
      ccode== kCmdStat || ccode==kCmdAttn ||
      ccode== kCmdInit) {
    os << " d=" << RosPrintBvi(fData, dbase);    
 
    if (fpExpect &&
        (ccode==kCmdRreg || ccode==kCmdStat || ccode==kCmdAttn)) {
      if (TestFlagAny(kFlagChkData)) {
        os << "#";
        os << " D=" << RosPrintBvi(fpExpect->DataValue(), dbase);
        if (fpExpect->DataMask() != 0x0000)  {
          os << "," << RosPrintBvi(fpExpect->DataMask(), dbase);
        }
      } else if (fpExpect->DataIsChecked()) {
        os << "!";
      } else {
        os << " ";
      }
    } else {
      os << " ";
    }
  }
 
  if (ccode== kCmdRblk || ccode==kCmdWblk) {
    os << " n=" << RosPrintf(BlockSize(), "d", 3); 
  }
 
  // ccmd field
  if (ccode == kCmdStat) {
    os << " c=" << RosPrintBvi(fStatRequest, 8);    
  }
 
  // status field
  os << " s=" << RosPrintBvi(fStatus, sbase);
  uint8_t scval  = fpExpect ? fpExpect->StatusValue() : cntx.StatusValue();
  uint8_t scmsk  = fpExpect ? fpExpect->StatusMask()  : cntx.StatusMask();
  if (TestFlagAny(kFlagChkStat)) {
    os << "#";
    os << " S=" << RosPrintBvi(scval, sbase);
    if (scmsk != 0x00) {
      os << "," << RosPrintBvi(scmsk, sbase);
    }
  } else {
    os << ( scmsk != 0xff ? "!" : " " );
  }
 
  if (TestFlagAny(kFlagDone)) {
    if (TestFlagAny(kFlagChkStat|kFlagChkData)) {
      os << " FAIL: " 
         << Rtools::Flags2String(fFlags&(kFlagChkStat|kFlagChkData),
                                 FlagNames(),',');
    } else {
      os << " OK";
    }
    if (TestFlagAny(kFlagRecov|kFlagResend)) os << " WARN: retried";
  } else if (TestFlagAny(kFlagSend)) {
    os << " FAIL: "
       << Rtools::Flags2String(fFlags&(kFlagErrNak|kFlagErrMiss|
                                       kFlagErrCmd|kFlagErrCrc),
                               FlagNames(),',');
  } else {
    os << " PEND";
  }
 
  // handle data part of rblk and wblk commands
  size_t dwidth = (dbase==2) ? 16 : ((dbase==8) ? 6 : 4);  
 
  if (ccode==kCmdRblk) {
    bool  dcheck = (fpExpect && fpExpect->BlockValue().size() > 0);
    size_t ncol  = (80-4-5)/(dwidth+2);
 
    size_t size  = BlockSize();
    const uint16_t* pdat = BlockPointer();
 
    for (size_t i=0; i<size; i++) {
      if (i%ncol == 0) os << "\n    " << RosPrintf(i,"d",3) << ": ";
      os << RosPrintBvi(pdat[i], dbase);
      if (dcheck) {
        if (!fpExpect->BlockCheck(i, pdat[i])) {
          os << "#";
        } else {
          os << (fpExpect->BlockIsChecked(i) ? "!" : "-");
        }
      } else {
        os << " ";
      }
      os << " ";
    }
 
    if (dcheck && TestFlagAny(kFlagChkData)) {
      const vector<uint16_t>& evalvec = fpExpect->BlockValue();
      const vector<uint16_t>& emskvec = fpExpect->BlockMask();
      for (size_t i=0; i<size; i++) {
        if (!fpExpect->BlockCheck(i, pdat[i])) {
          os << "\n      FAIL d[" << RosPrintf(i,"d",3) << "]: "
             << RosPrintBvi(pdat[i], dbase) << "#"
             << "  D=" << RosPrintBvi(evalvec[i], dbase);
          if (i < emskvec.size() && emskvec[i]!=0x0000) {
            os << "," << RosPrintBvi(emskvec[i], dbase);
          }
        }
      }
    } 
  }
 
  if (ccode==kCmdWblk) {
    const uint16_t* pdat = BlockPointer();
    size_t size = BlockSize();
    size_t ncol = (80-4-5)/(dwidth+2);
    for (size_t i=0; i<size; i++) {
      if (i%ncol == 0) os << "\n    " << RosPrintf(i,"d",3) << ": ";
      os << RosPrintBvi(pdat[i], dbase) << "  ";
    }
  }
 
  os << endl;
 
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RlinkCommand::Dump(std::ostream& os, int ind, const char* text) const
{
  RosFill bl(ind);
  os << bl << (text?text:"--") << "RlinkCommand @ " << this << endl;
 
  os << bl << "  fRequest:        " << RosPrintBvi(fRequest,8)
     << "  seq:" << RosPrintf(SeqNumber(),"d",2)
     << "  cmd:" << RosPrintf(Command(),"d",1)
     << " " << CommandName(Command()) << endl;
  os << bl << "  fAddress:        " << RosPrintBvi(fAddress,0) << endl;
  os << bl << "  fData:           " << RosPrintBvi(fData,0) << endl;
  os << bl << "  fBlock.size:     " << RosPrintf(fBlock.size(),"d",3) << endl;
  os << bl << "  fpBlockExt:      " << fpBlockExt << endl;
  os << bl << "  fBlockExtSize:   " << RosPrintf(fBlockExtSize,"d",3) << endl;
  os << bl << "  fStatRequest:    " << RosPrintBvi(fStatRequest,0) << endl;
  os << bl << "  fStatus:         " << RosPrintBvi(fStatus,0) << endl;
  os << bl << "  fFlags:          " << RosPrintBvi(fFlags,16,24)
           << "  " << Rtools::Flags2String(fFlags, FlagNames()) << endl;
  os << bl << "  fRcvSize:        " << RosPrintf(fRcvSize,"d",4) << endl;
  if (BlockSize() > 0) {
    size_t ncol  = max(1, (80-ind-4-5)/(4+1));
    os << bl << "  block data:";
    for (size_t i=0; i<BlockSize(); i++) {
      if (i%ncol == 0) os << "\n" << bl << "    " << RosPrintf(i,"d",3) << ": ";
      os << RosPrintBvi(BlockPointer()[i],16) << " ";
    }
    os << endl;
  }
  if (fpExpect) fpExpect->Dump(os, ind+2, "fpExpect: ");
 
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
const char* RlinkCommand::CommandName(uint8_t cmd)
{
  static const char* cmdname[8] = {"rreg","rblk","wreg","wblk",
                                   "stat","attn","init","????"};
 
  return cmdname[cmd&0x7];
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
const Retro::RflagName* RlinkCommand::FlagNames()
{
  // use msb first order, will also be printing order
  static Retro::RflagName fnam[] = {
    {kFlagChkData, "ChkData"},
    {kFlagChkStat, "ChkStat"},
    {kFlagErrCrc,  "ErrCrc"},
    {kFlagErrCmd,  "ErrCmd"},
    {kFlagErrMiss, "ErrMiss"},
    {kFlagErrNak,  "ErrNak"},
    {kFlagResend,  "Resend"},
    {kFlagRecov,   "Recov"},
    {kFlagPktEnd,  "PktEnd"},
    {kFlagPktBeg,  "PktBeg"},
    {kFlagDone,    "Done"},
    {kFlagSend,    "Send"},
    {kFlagInit,    "Init"},
    {0u, ""}
  };
  return fnam;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
RlinkCommand& RlinkCommand::operator=(const RlinkCommand& rhs)
{
  if (&rhs == this) return *this;
  fRequest      = rhs.fRequest;
  fAddress      = rhs.fAddress; 
  fData         = rhs.fData;
  fBlock        = rhs.fBlock;
  fpBlockExt    = rhs.fpBlockExt; 
  fBlockExtSize = rhs.fBlockExtSize; 
  fStatRequest  = rhs.fStatRequest;
  fStatus       = rhs.fStatus; 
  fFlags        = rhs.fFlags;
  fRcvSize      = rhs.fRcvSize;
  delete fpExpect;
  fpExpect      = rhs.fpExpect ? new RlinkCommandExpect(*rhs.fpExpect) : 0;
  return *this;
}
 
} // end namespace Retro