cpp/html/Rw11CntlDEUNA_8cpp_source.html

// $Id: Rw11CntlDEUNA.cpp 1186 2019-07-12 17:49:59Z mueller $

// SPDX-License-Identifier: GPL-3.0-or-later

// Copyright 2014-2019 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>

//

// Revision History:

// Date         Rev Version  Comment

// 2019-06-15  1164   0.5.10 adapt to new RtimerFd API

// 2019-04-19  1133   0.5.9  use ExecWibr()

// 2019-02-23  1114   0.5.8  use std::bind instead of lambda

// 2018-12-19  1090   0.5.7  use RosPrintf(bool)

// 2018-12-17  1087   0.5.6  use std::lock_guard instead of boost

// 2018-12-15  1082   0.5.5  use lambda instead of boost::bind

// 2018-12-09  1080   0.5.4  use HasVirt(); Virt() returns ref

// 2018-12-08  1078   0.5.3  BUGFIX: Start(Tx|Rx)Ring, was broken in r1049

//                             when fixing -Wunused-variable warnings

// 2018-11-30  1075   0.5.2  use list-init

// 2018-09-22  1048   0.5.1  BUGFIX: coverity (resource leak)

// 2017-04-17   880   0.5    Initial version (minimal functions, 211bsd ready)

// 2014-06-09   561   0.1    First draft

// ---------------------------------------------------------------------------


#include <string.h>

#include <fcntl.h>

#include <unistd.h>


#include <sstream>

#include <functional>


#include "librtools/RosFill.hpp"

#include "librtools/RosPrintBvi.hpp"

#include "librtools/RosPrintf.hpp"

#include "librtools/Rexception.hpp"

#include "librtools/RlogMsg.hpp"

#include "librtools/Rtools.hpp"


#include "RethTools.hpp"


#include "Rw11CntlDEUNA.hpp"


using namespace std;

using namespace std::placeholders;


// all method definitions in namespace Retro

namespace Retro {


//------------------------------------------+-----------------------------------

// constants definitions


const uint16_t Rw11CntlDEUNA::kIbaddr;

const int      Rw11CntlDEUNA::kLam;


const uint16_t Rw11CntlDEUNA::kPR0;

const uint16_t Rw11CntlDEUNA::kPR1;

const uint16_t Rw11CntlDEUNA::kPR2;

const uint16_t Rw11CntlDEUNA::kPR3;


const uint16_t Rw11CntlDEUNA::kProbeOff;

const bool     Rw11CntlDEUNA::kProbeInt;

const bool     Rw11CntlDEUNA::kProbeRem;


const uint16_t Rw11CntlDEUNA::kPR0_M_SERI;

const uint16_t Rw11CntlDEUNA::kPR0_M_PCEI;

const uint16_t Rw11CntlDEUNA::kPR0_M_RXI;

const uint16_t Rw11CntlDEUNA::kPR0_M_TXI;

const uint16_t Rw11CntlDEUNA::kPR0_M_DNI;

const uint16_t Rw11CntlDEUNA::kPR0_M_RCBI;

const uint16_t Rw11CntlDEUNA::kPR0_M_USCI;

const uint16_t Rw11CntlDEUNA::kPR0_M_INTR;

const uint16_t Rw11CntlDEUNA::kPR0_M_INTE;

const uint16_t Rw11CntlDEUNA::kPR0_M_RSET;

const uint16_t Rw11CntlDEUNA::kPR0_M_BRST;

const uint16_t Rw11CntlDEUNA::kPR0_M_PCMD;


const uint16_t Rw11CntlDEUNA::kPR0_V_PCMDBP;

const uint16_t Rw11CntlDEUNA::kPR0_B_PCMDBP;

const uint16_t Rw11CntlDEUNA::kPR0_M_PDMDWB;

const uint16_t Rw11CntlDEUNA::kPR0_M_PCWWB;


const uint16_t Rw11CntlDEUNA::kPCMD_NOOP;

const uint16_t Rw11CntlDEUNA::kPCMD_GETPCBB;

const uint16_t Rw11CntlDEUNA::kPCMD_GETCMD;

const uint16_t Rw11CntlDEUNA::kPCMD_SELFTST;

const uint16_t Rw11CntlDEUNA::kPCMD_START;

const uint16_t Rw11CntlDEUNA::kPCMD_BOOT;

const uint16_t Rw11CntlDEUNA::kPCMD_PDMD;

const uint16_t Rw11CntlDEUNA::kPCMD_HALT;

const uint16_t Rw11CntlDEUNA::kPCMD_STOP;


const uint16_t Rw11CntlDEUNA::kPR1_M_XPWR;

const uint16_t Rw11CntlDEUNA::kPR1_M_ICAB;

const uint16_t Rw11CntlDEUNA::kPR1_M_PCTO;

const uint16_t Rw11CntlDEUNA::kPR1_M_DELUA;

const uint16_t Rw11CntlDEUNA::kPR1_M_STATE;


const uint16_t Rw11CntlDEUNA::kSTATE_RESET;

const uint16_t Rw11CntlDEUNA::kSTATE_PLOAD;

const uint16_t Rw11CntlDEUNA::kSTATE_READY;

const uint16_t Rw11CntlDEUNA::kSTATE_RUN;

const uint16_t Rw11CntlDEUNA::kSTATE_UHALT;

const uint16_t Rw11CntlDEUNA::kSTATE_NHALT;

const uint16_t Rw11CntlDEUNA::kSTATE_NUHALT;

const uint16_t Rw11CntlDEUNA::kSTATE_PHALT;

const uint16_t Rw11CntlDEUNA::kSTATE_SLOAD;


const uint16_t Rw11CntlDEUNA::kPC0_M_FUNC;

const uint16_t Rw11CntlDEUNA::kPC0_M_MBZ;


const uint16_t Rw11CntlDEUNA::kFUNC_NOOP;

const uint16_t Rw11CntlDEUNA::kFUNC_RDPA;

const uint16_t Rw11CntlDEUNA::kFUNC_RPA;

const uint16_t Rw11CntlDEUNA::kFUNC_WPA;

const uint16_t Rw11CntlDEUNA::kFUNC_RMAL;

const uint16_t Rw11CntlDEUNA::kFUNC_WMAL;

const uint16_t Rw11CntlDEUNA::kFUNC_RRF;

const uint16_t Rw11CntlDEUNA::kFUNC_WRF;

const uint16_t Rw11CntlDEUNA::kFUNC_RCTR;

const uint16_t Rw11CntlDEUNA::kFUNC_RCCTR;

const uint16_t Rw11CntlDEUNA::kFUNC_RMODE;

const uint16_t Rw11CntlDEUNA::kFUNC_WMODE;

const uint16_t Rw11CntlDEUNA::kFUNC_RSTAT;

const uint16_t Rw11CntlDEUNA::kFUNC_RCSTAT;

const uint16_t Rw11CntlDEUNA::kFUNC_RSID;

const uint16_t Rw11CntlDEUNA::kFUNC_WSID;


const uint16_t Rw11CntlDEUNA::kSTAT_M_ERRS;

const uint16_t Rw11CntlDEUNA::kSTAT_M_MERR;

const uint16_t Rw11CntlDEUNA::kSTAT_M_BABL;

const uint16_t Rw11CntlDEUNA::kSTAT_M_CERR;

const uint16_t Rw11CntlDEUNA::kSTAT_M_TMOT;

const uint16_t Rw11CntlDEUNA::kSTAT_M_RRNG;

const uint16_t Rw11CntlDEUNA::kSTAT_M_TRNG;

const uint16_t Rw11CntlDEUNA::kSTAT_M_PTCH;

const uint16_t Rw11CntlDEUNA::kSTAT_M_RRAM;

const uint16_t Rw11CntlDEUNA::kSTAT_M_RREV;


const uint16_t Rw11CntlDEUNA::kMODE_M_PROM;

const uint16_t Rw11CntlDEUNA::kMODE_M_ENAL;

const uint16_t Rw11CntlDEUNA::kMODE_M_DRDC;

const uint16_t Rw11CntlDEUNA::kMODE_M_TPAD;

const uint16_t Rw11CntlDEUNA::kMODE_M_ECT;

const uint16_t Rw11CntlDEUNA::kMODE_M_DMNT;

const uint16_t Rw11CntlDEUNA::kMODE_M_INTL;

const uint16_t Rw11CntlDEUNA::kMODE_M_DTCR;

const uint16_t Rw11CntlDEUNA::kMODE_M_LOOP;

const uint16_t Rw11CntlDEUNA::kMODE_M_HDPX;

const uint16_t Rw11CntlDEUNA::kMODE_M_MBZ_DEUNA;

const uint16_t Rw11CntlDEUNA::kMODE_M_MBZ_DELUA;


const uint16_t Rw11CntlDEUNA::kTXR2_M_OWN;

const uint16_t Rw11CntlDEUNA::kTXR2_M_ERRS;

const uint16_t Rw11CntlDEUNA::kTXR2_M_MTCH;

const uint16_t Rw11CntlDEUNA::kTXR2_M_MORE;

const uint16_t Rw11CntlDEUNA::kTXR2_M_ONE;

const uint16_t Rw11CntlDEUNA::kTXR2_M_DEF;

const uint16_t Rw11CntlDEUNA::kTXR2_M_STF;

const uint16_t Rw11CntlDEUNA::kTXR2_M_ENF;

const uint16_t Rw11CntlDEUNA::kTXR2_M_SEGB;

const uint16_t Rw11CntlDEUNA::kTXR3_M_BUFL;

const uint16_t Rw11CntlDEUNA::kTXR3_M_UBTO;

const uint16_t Rw11CntlDEUNA::kTXR3_M_UFLO;

const uint16_t Rw11CntlDEUNA::kTXR3_M_LCOL;

const uint16_t Rw11CntlDEUNA::kTXR3_M_LCAR;

const uint16_t Rw11CntlDEUNA::kTXR3_M_RTRY;

const uint16_t Rw11CntlDEUNA::kTXR3_M_TDR;


const uint16_t Rw11CntlDEUNA::kRXR2_M_OWN;

const uint16_t Rw11CntlDEUNA::kRXR2_M_ERRS;

const uint16_t Rw11CntlDEUNA::kRXR2_M_FRAM;

const uint16_t Rw11CntlDEUNA::kRXR2_M_OFLO;

const uint16_t Rw11CntlDEUNA::kRXR2_M_CRC;

const uint16_t Rw11CntlDEUNA::kRXR2_M_STF;

const uint16_t Rw11CntlDEUNA::kRXR2_M_ENF;

const uint16_t Rw11CntlDEUNA::kRXR2_M_SEGB;

const uint16_t Rw11CntlDEUNA::kRXR3_M_BUFL;

const uint16_t Rw11CntlDEUNA::kRXR3_M_UBTO;

const uint16_t Rw11CntlDEUNA::kRXR3_M_NCHN;

const uint16_t Rw11CntlDEUNA::kRXR3_M_OVRN;

const uint16_t Rw11CntlDEUNA::kRXR3_M_MLEN;


const uint32_t Rw11CntlDEUNA::kUBA_M;

const uint32_t Rw11CntlDEUNA::kUBAODD_M;

const uint16_t Rw11CntlDEUNA::kDimMcast;

const uint16_t Rw11CntlDEUNA::kDimCtrDeuna;

const uint16_t Rw11CntlDEUNA::kDimCtrDelua;

const uint16_t Rw11CntlDEUNA::kDimCtr;


//------------------------------------------+-----------------------------------


Rw11CntlDEUNA::Rw11CntlDEUNA()

  : Rw11CntlBase<Rw11UnitDEUNA,1>("deuna"),

    fPC_rdpr0(0),

    fPC_rdpcb(0),

    fPC_lapcb(0),

    fPC_rdtxdsccur(0),

    fPC_latxdsccur(0),

    fPC_rdtxdscnxt(0),

    fPC_latxdscnxt(0),

    fPC_rdrxdsccur(0),

    fPC_larxdsccur(0),

    fPC_rdrxdscnxt(0),

    fPcbbValid(false),

    fPcbb(0),

    fPcb{},

    fRingValid(false),

    fTxRingBase(0),

    fTxRingSize(0),

    fTxRingELen(0),

    fRxRingBase(0),

    fRxRingSize(0),

    fRxRingELen(0),

    fMacDefault(RethTools::String2Mac("08:00:2b:00:00:00")),

    fPr0Last(0),

    fPr1Pcto(false),

    fPr1Delua(false),

    fPr1State(kSTATE_RESET),

    fRunning(false),

    fMode(0),

    fStatus(0),

    fTxRingIndex(0),

    fRxRingIndex(0),

    fTxDscCurPC{},

    fTxDscNxtPC{},

    fRxDscCurPC{},

    fRxDscNxtPC{},

    fTxRingState(kStateTxIdle),

    fTxDscCur{},

    fTxDscNxt{},

    fTxBuf(),

    fTxBufOffset(0),

    fRxRingState(kStateRxIdle),

    fRxDscCur{},

    fRxDscNxt{},

    fRxPollTime(0.01),

    fRxQueLimit(1000),

    fRxPollTimer("Rw11CntlDEUNA::fRxPollTimer."),

    fRxBufQueue(),

    fRxBufCurr(),

    fRxBufOffset(0)

{

  // must be here because Units have a back-ptr (not available at Rw11CntlBase)

  fspUnit[0].reset(new Rw11UnitDEUNA(this, 0)); // single unit controller


  ClearMacList();

  ClearCtr();


  // setup fStats

  fStats.Define(kStatNPcmdNoop   , "NPcmdNoop"   , "pcmd NOOP (spurious)");

  fStats.Define(kStatNPcmdGetpcbb, "NPcmdGetpcbb", "pcmd GETPCBB");

  fStats.Define(kStatNPcmdGetcmd , "NPcmdGetcmd" , "pcmd GETCMD");

  fStats.Define(kStatNPcmdSelftst, "NPcmdSelftst", "pcmd SELFTST");

  fStats.Define(kStatNPcmdStart  , "NPcmdStart"  , "pcmd START");

  fStats.Define(kStatNPcmdPdmd   , "NPcmdPdmd"   , "pcmd PDMD");

  fStats.Define(kStatNPcmdStop   , "NPcmdStop"   , "pcmd STOP");

  fStats.Define(kStatNPcmdHalt   , "NPcmdHalt"   , "pcmd HALT");

  fStats.Define(kStatNPcmdRsrvd  , "NPcmdRsrvd"  , "pcmd reserved");

  fStats.Define(kStatNPcmdUimpl  , "NPcmdUimpl"  , "pcmd not implemented");

  fStats.Define(kStatNPcmdWBPdmd , "NPcmdWBPdmd" , "pcmd write w/ busy: pdmd");

  fStats.Define(kStatNPcmdWBOther, "NPcmdWBOther", "pcmd write w/ busy: other");

  fStats.Define(kStatNPdmdRestart, "NPdmdRestart", "pcmd pdmd restart");

  fStats.Define(kStatNFuncNoop   , "NFuncNoop"   , "func NOOP");

  fStats.Define(kStatNFuncRdpa   , "NFuncRdpa"   , "func RDPA");

  fStats.Define(kStatNFuncRpa    , "NFuncRpa"    , "func PRA");

  fStats.Define(kStatNFuncWpa    , "NFuncWpa"    , "func WPA");

  fStats.Define(kStatNFuncRmal   , "NFuncRmal"   , "func RMAL");

  fStats.Define(kStatNFuncWmal   , "NFuncWmal"   , "func WMAL");

  fStats.Define(kStatNFuncRrf    , "NFuncRrf"    , "func RRF");

  fStats.Define(kStatNFuncWrf    , "NFuncWrf"    , "func WRF");

  fStats.Define(kStatNFuncRctr   , "NFuncRctr"   , "func RCTR");

  fStats.Define(kStatNFuncRcctr  , "NFuncRcctr"  , "func RCCTR");

  fStats.Define(kStatNFuncRmode  , "NFuncRmode"  , "func RMODE");

  fStats.Define(kStatNFuncWmode  , "NFuncWmode"  , "func WMODE");

  fStats.Define(kStatNFuncRstat  , "NFuncRstat"  , "func RSTAT");

  fStats.Define(kStatNFuncRcstat , "NFuncRcstat" , "func RCSTAT");

  fStats.Define(kStatNFuncRsid   , "NFuncRsid"   , "func RSID");

  fStats.Define(kStatNFuncWsid   , "NFuncWsid"   , "func WSID");

  fStats.Define(kStatNFuncUimpl  , "NFuncUimpl"  , "func not implemented");

  fStats.Define(kStatNRxFraSeen  , "NRxFraSeen"  , "in frames seen");

  fStats.Define(kStatNRxFraFDst  , "NRxFraFDst"  , "in frames match dst mac");

  fStats.Define(kStatNRxFraFBcast, "NRxFraFBcast", "in frames match bcast");

  fStats.Define(kStatNRxFraFMcast, "NRxFraFMcast", "in frames match mcast");

  fStats.Define(kStatNRxFraFProm , "NRxFraFProm" , "in frames promiscous");

  fStats.Define(kStatNRxFraFUDrop, "NRxFraFUDrop", "in frames drop miss mac");

  fStats.Define(kStatNRxFraFMDrop, "NRxFraFMDrop", "in frames drop miss mcast");

  fStats.Define(kStatNRxFraQLDrop, "NRxFraQLDrop", "in frames drop drop");

  fStats.Define(kStatNRxFraNRDrop, "NRxFraNRDrop", "in frames drop not running");

  fStats.Define(kStatNRxFra      , "NRxFra"      , "rcvd frames");

  fStats.Define(kStatNRxFraMcast , "NRxFraMcast" , "rcvd bcast+mcast frames");

  fStats.Define(kStatNRxFraBcast , "NRxFraBcast" , "rcvd bcast frames");

  fStats.Define(kStatNRxByt      , "NRxByt"      , "rcvd bytes");

  fStats.Define(kStatNRxBytMcast , "NRxBytMcast" , "rcvd mcast bytes");

  fStats.Define(kStatNRxFraLoInt , "NRxFraLoInt" , "lost frames int err ");

  fStats.Define(kStatNRxFraLoBuf , "NRxFraLoBuf" , "lost frames buffer");

  fStats.Define(kStatNRxFraPad   , "NRxFraPad"   , "rcvd padded frames");

  fStats.Define(kStatNTxFra      , "NTxFra"      , "xmit frames");

  fStats.Define(kStatNTxFraMcast , "NTxFraMcast" , "xmit bcast+mcast frames");

  fStats.Define(kStatNTxFraBcast , "NTxFraBcast" , "xmit bcast frames");

  fStats.Define(kStatNTxByt      , "NTxByt"      , "xmit bytes");

  fStats.Define(kStatNTxBytMcast , "NTxBytMcast" , "xmit mcast bytes");

  fStats.Define(kStatNTxFraAbort , "NTxFraAbort" , "xmit aborted frames");

  fStats.Define(kStatNTxFraPad   , "NTxFraPad"   , "xmit padded frames");

  fStats.Define(kStatNFraLoop    , "NFraLoop"    , "loopback frames");

}


//------------------------------------------+-----------------------------------


Rw11CntlDEUNA::~Rw11CntlDEUNA()

{}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::Config(const std::string& name, uint16_t base, int lam)

{

  ConfigCntl(name, base, lam, kProbeOff, kProbeInt, kProbeRem);

  return;

}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::Start()

{

  if (fStarted || fLam<0 || !fEnable || !fProbe.Found())

    throw Rexception("Rw11CntlDEUNA::Start",

                     "Bad state: started, no lam, not enabled, not found");


  // add device register address ibus and rbus mappings

  // done here because now Cntl bound to Cpu and Cntl probed

  Cpu().AllIAddrMapInsert(Name()+".pr0", Base() + kPR0);

  Cpu().AllIAddrMapInsert(Name()+".pr1", Base() + kPR1);

  Cpu().AllIAddrMapInsert(Name()+".pr2", Base() + kPR2);

  Cpu().AllIAddrMapInsert(Name()+".pr3", Base() + kPR3);


  // setup primary info clist

  SetupPrimClist();


  // ensure unit status is initialized

  fPr1State = kSTATE_READY;

  UnitSetupAll();


  // add attn handler

  Server().AddAttnHandler(bind(&Rw11CntlDEUNA::AttnHandler, this, _1),

                          uint16_t(1)<<fLam, this);

  fStarted = true;


  return;

}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::UnitSetup(size_t /*ind*/)

{

  Cpu().ExecWibr(fBase+kPR1, GetPr1());

  // FIXME_code !!! Is that all ???

  return;

}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::SetType(const std::string& type)

{

  if (fPr1State != kSTATE_READY || fspUnit[0]->HasVirt())

    throw Rexception("Rw11CntlDEUNA::SetType",

                     string("Bad state: not in READY state or attached"));


  if (type == "deuna") {

    fPr1Delua = false;

  } else if (type == "delua") {

    fPr1Delua = true;

  } else {

    throw Rexception("Rw11CntlDEUNA::SetType",

                     string("Bad args: only deuna or delua supported"));

  }

  fType = type;

  UnitSetup(0);

  return;

}


//------------------------------------------+-----------------------------------

//  allow xx:xx:xx:xx:xx:xx

//        random        --> random mac, with 1st bit=0; 2nd bit=1 (LAA)

//        dec:xx:xx:xx  --> 08:00:0b:xx:xx:xx --> DEC OUI

//        retro::xx     --> 52:65:74:72:6f:xx --> ascii 'Retro'

//          'R' = 52 -> 2nd bit = 1 -> locally administered address


void Rw11CntlDEUNA::SetMacDefault(const std::string& mac)

{

  string machex = mac;

  uint64_t bmac;

  const uint64_t macbit1 = 0x1;

  const uint64_t macbit2 = 0x2;


  if (mac == "random") {

    int fd = ::open("/dev/urandom",O_RDONLY);

    if (fd < 0)

      throw Rexception("Rw11CntlDEUNA::SetMacDefault",

                       "open() for '/dev/urandom' failed: ", errno);


    if (::read(fd, &bmac, sizeof(bmac)) != sizeof(bmac)) {

      int rd_errno = errno;

      ::close(fd);

      throw Rexception("Rw11CntlDEUNA::SetMacDefault",

                       "read() for '/dev/random' failed: ", rd_errno);

    }

    bmac &= ~macbit1;                       // ensure bcast bit is clear

    bmac |=  macbit2;                       // ensure laa   bit is set

    ::close(fd);


  } else {

    if (mac.substr(0,4) == "dec:") {

      machex  = "08:00:0b:";                  // DEC OUI

      machex += mac.substr(4);

    } else if (mac.substr(0,6) == "retro:") {

      machex  = "52:65:74:72:6f:";            // ascii 'Retro'; 52 -> LAA

      machex += mac.substr(6);

    }


    bmac = RethTools::String2Mac(machex);

  }


  if (bmac & macbit1)

    throw Rexception("Rw11CntlDEUNA::SetMacDefault",

                     string("Bad args: mcast address given, lsb not 0"));

  if (fPr1State == kSTATE_READY &&          // if not running

      (!fspUnit[0]->HasVirt()) &&           // and not attached

      fMacList[0] == fMacDefault) {         // and old pa was old dpa

    fMacList[0] = bmac;                     // update also pa !

  }

  fMacDefault = bmac;                       // and always dpa !

  return;

}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::SetRxPollTime(const Rtime& time)

{

  if (!time.IsPositive())

    throw Rexception("Rw11CntlDEUNA::SetRxPollTime",

                     string("Bad args: time <= 0"));

  fRxPollTime = time;

  return;

}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::SetRxQueLimit(size_t rxqlim)

{

  if (rxqlim <= 0)

    throw Rexception("Rw11CntlDEUNA::SetRxQueLimit",

                     string("Bad args: rxqlim <= 0"));

  fRxQueLimit = rxqlim;

  return;

}


//--------------------------------------+-----------------------------------


std::string Rw11CntlDEUNA::MacDefault() const

{

  return RethTools::Mac2String(fMacDefault);

}


//--------------------------------------+-----------------------------------


const char* Rw11CntlDEUNA::MnemoPcmd(uint16_t pcmd) const

{

  static const char* mnemopcmd[16] = {"noop  ","getpcb","getcmd","slftst",

                                      "start ","boot  ","rsrv06","rsrv07",

                                      "pdmd  ","rsrv11","rsrv12","rsrv13",

                                      "rsrv14","rsrv15","halt  ","stop  "};

  if (pcmd >= 16) return "??????";

  return mnemopcmd[pcmd];

}


//--------------------------------------+-----------------------------------


const char* Rw11CntlDEUNA::MnemoFunc(uint16_t func) const

{

  static const char* mnemofunc[32] = {"noop  ","uimp01","rdpa  ","noop03",

                                      "rpa   ","wpa   ","rmal  ","wmal  ",

                                      "rrf   ","wrf   ","rctr  ","rcctr ",

                                      "rmode ","wmode ","rstat ","rcstat",

                                      "uimp20","uimp21","rsid  ","wsid  ",

                                      "uimp24","uimp25","uimp26","uimp27",

                                      "uimp30","uimp31","uimp32","uimp33",

                                      "uimp34","uimp35","uimp36","uimp37"};

  if (func >= 32) return "??????";

  return mnemofunc[func];

}


//--------------------------------------+-----------------------------------


const char* Rw11CntlDEUNA::MnemoState(uint16_t state) const

{

  static const char* mnemostate[16] = {"reset ","pload ","ready ","run   ",

                                       "rsrv04","uhalt ","nhalt ","nuhalt",

                                       "phalt ","rsrv11","rsrv12","rsrv13",

                                       "rsrv14","rsrv15","rsrv16","sload "};

  if (state >= 16) return "??????";

  return mnemostate[state];

}


//------------------------------------------+-----------------------------------


bool Rw11CntlDEUNA::RcvCallback(RethBuf::pbuf_t& pbuf)

{

  // lock connect to protect rxqueue

  lock_guard<RlinkConnect> lock(Connect());


  fStats.Inc(kStatNRxFraSeen);

  if (!Running()) {                         // drop if not running

    fStats.Inc(kStatNRxFraNRDrop);

    return true;

  }


  uint64_t macdst = pbuf->MacDestination();

  int matchdst = MacFilter(macdst);


  if (matchdst < 0) {                       // not matched ?

    if (fMode & kMODE_M_PROM) {               // promiscous mode

      fStats.Inc(kStatNRxFraFProm);             // count and accept

    } else {                                  // otherwise drop

      if (matchdst & 0x1) {                     // mcast address

        fStats.Inc(kStatNRxFraFMDrop);

      } else {

        fStats.Inc(kStatNRxFraFUDrop);

      }

      if (fTraceLevel>1) {

        RlogMsg lmsg(LogFile());

        lmsg << "-I " << Name() << ": fdrop " << pbuf->FrameInfo() << endl;

      }

      return true;

    }

  } else {                                  // machted

    if (matchdst == 0) {

      fStats.Inc(kStatNRxFraFDst);

    } else if (matchdst == 1) {

      fStats.Inc(kStatNRxFraFBcast);

    } else {

      fStats.Inc(kStatNRxFraFMcast);

    }

  }


  if (fRxBufQueue.size() >= fRxQueLimit) {  // drop if queue too long

    fStats.Inc(kStatNRxFraQLDrop);

    if (fTraceLevel>0) {

      RlogMsg lmsg(LogFile());

      lmsg << "-I " << Name() << ": qdrop " << pbuf->FrameInfo() << endl;

    }

    return true;

  }


  fRxBufQueue.push_back(pbuf);


  // FIXME_code: can we (should we) use last cached dscs ???

  if (fTxRingState == kStateTxIdle) StartRxRing();


  return true;

}


//------------------------------------------+-----------------------------------


void Rw11CntlDEUNA::Dump(std::ostream& os, int ind, const char* text,

                         int detail) const

{

  // lock connect to protect, e.g fRxBufQueue access

  lock_guard<RlinkConnect> lock(Connect());


  RosFill bl(ind);

  os << bl << (text?text:"--") << "Rw11CntlDEUNA @ " << this << endl;

  os << bl << "  fPC_rdpr0:        " << fPC_rdpr0 << endl;

  os << bl << "  fPC_rdpcb:        " << fPC_rdpcb << endl;

  os << bl << "  fPC_lapcb:        " << fPC_lapcb << endl;

  os << bl << "  fPC_rdtxdsccur:   " << fPC_rdtxdsccur << endl;

  os << bl << "  fPC_latxdsccur:   " << fPC_latxdsccur << endl;

  os << bl << "  fPC_rdtxdscnxt:   " << fPC_rdtxdscnxt << endl;

  os << bl << "  fPC_latxdscnxt:   " << fPC_latxdscnxt << endl;

  os << bl << "  fPC_rdrxdsccur:   " << fPC_rdrxdsccur << endl;

  os << bl << "  fPC_larxdsccur:   " << fPC_larxdsccur << endl;

  os << bl << "  fPC_rdrxdscnxt:   " << fPC_rdrxdscnxt << endl;

  os << bl << "  fPcbbValid:       " << RosPrintf(fPcbbValid) << endl;

  os << bl << "  fPcbb:            " << RosPrintf(fPcbb,"o0", 6) << endl;

  os << bl << "  fPcb:            ";

  for (auto& v : fPcb) os << " " << RosPrintf(v,"o0", 6);

  os << endl;


  os << bl << "  fRingValid:       " << RosPrintf(fRingValid) << endl;

  os << bl << "  fTxRing format:   " << RosPrintf(fTxRingBase,"o0", 7)

     << "," << RosPrintf(fTxRingSize,"d", 3)

     << "," << RosPrintf(fTxRingELen,"d", 3) << endl;

  os << bl << "  fRxRing format:   " << RosPrintf(fRxRingBase,"o0", 7)

     << "," << RosPrintf(fRxRingSize,"d", 3)

     << "," << RosPrintf(fRxRingELen,"d", 3) << endl;


  os << bl << "  fMacDefault:      "

     << RosPrintf(fMacDefault,"x0",12)   << "  "

     << RethTools::Mac2String(fMacDefault) << endl;

  os << bl << "  fMacList[0]:      "

     << RosPrintf(fMacList[0],"x0",12) << "  "

     << RethTools::Mac2String(fMacList[0]) << endl;

  os << bl << "  fMacList[1]:      "

     << RosPrintf(fMacList[1],"x0",12)  << "  "

     << RethTools::Mac2String(fMacList[1]) << endl;

  os << bl << "  fMacastCnt:       " << RosPrintf(fMcastCnt,"d", 2) << endl;

  for (int i=0; i<fMcastCnt; i++) {

    os << bl << "  fMacList[" << RosPrintf(i,"d",2) << "]:    "

       << RosPrintf(fMacList[2+i],"x0",12)  << "  "

       << RethTools::Mac2String(fMacList[2+i]) << endl;

  }


  os << bl << "  fPr0Last*:       " << RosPrintf(fPr0Last,"o0", 6) << endl;

  os << bl << "  fPr1*:           "

     << " Pcto="  << RosPrintf(fPr1Pcto)

     << " Delua=" << RosPrintf(fPr1Delua)

     << " State=" << RosPrintf(fPr1State,"o0", 2) << ":" << MnemoState(fPr1State)

     << " GetPr1()=" << RosPrintf(GetPr1(),"o0", 6) << endl;

  os << bl << "  fRunning:         " << RosPrintf(fRunning) << endl;

  os << bl << "  fMode:            " << RosPrintf(fMode,"o0", 6) << endl;

  os << bl << "  fStatus:          " << RosPrintf(fStatus,"o0", 6) << endl;


  os << bl << "  fTxRingIndex:     " << RosPrintf(fTxRingIndex,"d", 3) << endl;

  os << bl << "  fRxRingIndex:     " << RosPrintf(fRxRingIndex,"d", 3) << endl;

  os << bl << "  fTxDscCurPC:      " << RingDsc2String(fTxDscCurPC,'t') << endl;

  os << bl << "  fTxDscNxtPC:      " << RingDsc2String(fTxDscNxtPC,'t') << endl;

  os << bl << "  fRxDscCurPC:      " << RingDsc2String(fRxDscCurPC,'r') << endl;

  os << bl << "  fRxDscNxtPC:      " << RingDsc2String(fRxDscNxtPC,'r') << endl;

  os << bl << "  fTxRingState:     " << fTxRingState << endl;

  os << bl << "  fTxDscCur:        " << RingDsc2String(fTxDscCur,'t') << endl;

  os << bl << "  fTxDscNxt:        " << RingDsc2String(fTxDscNxt,'t') << endl;

  fTxBuf.Dump(os, ind+2, "fTxBuf:", detail);

  os << bl << "  fRxRingState:     " << fRxRingState << endl;

  os << bl << "  fRxDscCur:        " << RingDsc2String(fRxDscCur,'r') << endl;

  os << bl << "  fRxDscNxt:        " << RingDsc2String(fRxDscNxt,'r') << endl;


  os << bl << "  fRxPollTime:      " << fRxPollTime << endl;

  os << bl << "  fRxQueLimit:      " << RosPrintf(fRxQueLimit,"d", 4)  << endl;

  os << bl << "  fRxPollTimer:     " << fRxPollTimer.Fd()  << endl;

  size_t rxquesize = fRxBufQueue.size();

  os << bl << "  fRxBufQueue.size: " << RosPrintf(rxquesize,"d", 4) << endl;

  for (size_t i=0; i<rxquesize; i++) {

    os << bl << "  fRxBufQueue[" << RosPrintf(i,"d", 4)

       << "]: " << fRxBufQueue[i]->FrameInfo() << endl;

  }

  if (fRxBufCurr) {

    fRxBufCurr->Dump(os, ind+2, "fRxBufCurr:", detail);

  } else {

    os << bl << "  fRxBufCurr:       " << "null" << endl;

  }

  os << bl << "  fCtrTimeCleared:  "

     << RosPrintf(fCtrTimeCleared.Age(CLOCK_MONOTONIC),"f",10,2) << endl;

  os << bl << "  fCtrRxFra:        "

     << RosPrintf(fCtrRxFra,"d",10) << endl;

  os << bl << "  fCtrRxFraMcast:   "

     << RosPrintf(fCtrRxFraMcast,"d",10) << endl;

  os << bl << "  fCtrRxByt:        "

     << RosPrintf(fCtrRxByt,"d",10) << endl;

  os << bl << "  fCtrRxBytMcast:   "

     << RosPrintf(fCtrRxBytMcast,"d",10) << endl;

  os << bl << "  fCtrRxFraLoInt:   "

     << RosPrintf(fCtrRxFraLoInt,"d",10) << endl;

  os << bl << "  fCtrRxFraLoBuf:   "

     << RosPrintf(fCtrRxFraLoBuf,"d",10) << endl;

  os << bl << "  fCtrTxFra:        "

     << RosPrintf(fCtrTxFra,"d",10) << endl;

  os << bl << "  fCtrTxFraMcast:   "

     << RosPrintf(fCtrTxFraMcast,"d",10) << endl;

  os << bl << "  fCtrTxByt:        "

     << RosPrintf(fCtrTxByt,"d",10) << endl;

  os << bl << "  fCtrTxBytMcast:   "

     << RosPrintf(fCtrTxBytMcast,"d",10) << endl;

  os << bl << "  fCtrTxFraAbort:   "

     << RosPrintf(fCtrTxFraAbort,"d",10) << endl;

  os << bl << "  fCtrFramesLoop:   "

     << RosPrintf(fCtrFraLoop,"d",10) << endl;

  Rw11CntlBase<Rw11UnitDEUNA,1>::Dump(os, ind, " ^", detail);

  return;

}


//--------------------------------------+-----------------------------------


// summary of log entry

// handler lines

// -I xua: cmd pr0=oooooo rset=b brst=b

// -I xua: cmd pr0=000110 cmd=......

// -I xua: cmd pr0=000110 cmd=pdmd   t00,OSE,OSE r00,OSE,OSE

// -I xua: cmd pr0=oooooo cmd=getcmd fu=...... udbb=oooooo

// -I xua: txr t00 < dddd,oooooo,dddd; bbbbbbbb,bbbb: OSE, ...

// -I xua: snd 00:00:00:00:00:00 > 00:00:00:00:00:00 typ: xxxx len: dddd

// command specific lines

// -I xua: GETPCBB: oooooo

// -I xua: RPA: 08:00:2b:00:00:00

// -I xua: WRF: tx base=oooooo size=dd elen=dd; rx base=oooooo size=dd elen=dd

// -I xua: WMODE: mode=oooooo


int Rw11CntlDEUNA::AttnHandler(RlinkServer::AttnArgs& args)

{

  fStats.Inc(kStatNAttnHdl);


  Rw11Cpu& cpu = Cpu();

  if (fPC_rdtxdsccur > 0) {                   // txdsc read update, if setup

    cpu.ModLalh(fPrimClist, fPC_rdtxdsccur, TxRingDscAddr(fTxRingIndex),

                Rw11Cpu::kCPAH_M_UBM22);

    cpu.ModLalh(fPrimClist, fPC_rdtxdscnxt, TxRingDscAddr(TxRingIndexNext()),

                Rw11Cpu::kCPAH_M_UBM22);

    cpu.ModLalh(fPrimClist, fPC_rdrxdsccur, RxRingDscAddr(fRxRingIndex),

                Rw11Cpu::kCPAH_M_UBM22);

    cpu.ModLalh(fPrimClist, fPC_rdrxdscnxt, RxRingDscAddr(RxRingIndexNext()),

                Rw11Cpu::kCPAH_M_UBM22);

  }


  Server().GetAttnInfo(args, fPrimClist);

  // FIXME_code: handle pcb and txdsc read errors ...


  fPr0Last = fPrimClist[fPC_rdpr0].Data();


  bool     rset  = fPr0Last & kPR0_M_RSET;

  bool     brst  = fPr0Last & kPR0_M_BRST;

  uint16_t pcmd  = (fPr0Last>>kPR0_V_PCMDBP) & kPR0_B_PCMDBP;


  // check for pcmd write while busy

  if (fPr0Last & kPR0_M_PCWWB) {

    uint16_t pcmdwwb  = fPr0Last & kPR0_M_PCMD;

    if (pcmdwwb == kPCMD_PDMD) {

      fStats.Inc(kStatNPcmdWBPdmd);

    } else {

      fStats.Inc(kStatNPcmdWBOther);

      RlogMsg lmsg(LogFile());

      lmsg << "-E " << Name() << ": pcmd write w/ busy"

           << " pr0=" << RosPrintBvi(fPr0Last,8)

           << " pcmd-1st=" << MnemoPcmd(pcmd)

           << " pcmd-2nd=" << MnemoPcmd(pcmdwwb);

    }

  }

  // check for pcmd  pdmd while busy restarts

  if (fPr0Last & kPR0_M_PDMDWB) {

    fStats.Inc(kStatNPdmdRestart);

  }


  RlinkCommandList clist;


  fPr1Pcto = false;

  uint16_t pr0out = 0;


  // handle bus and software reset: stop runnig, poll for RingHandler run-down

  if (rset || brst) {

    if (fTraceLevel>0) {

      RlogMsg lmsg(LogFile());

      lmsg << "-I " << Name() << ": cmd"

           << " pr0=" << RosPrintBvi(fPr0Last,8)

           << " rset=" << rset << " brst=" << brst;

    }

    Reset();

    if (rset) pr0out |= kPR0_M_RSET|kPR0_M_DNI;

    if (brst) pr0out |= kPR0_M_BRST;

    cpu.AddWibr(clist, fBase+kPR1, GetPr1());

    cpu.AddWibr(clist, fBase+kPR0, pr0out);

    Server().Exec(clist);

    return 0;

  }


  if (fTraceLevel>0) {

    RlogMsg lmsg(LogFile());

    lmsg << "-I " << Name() << ": cmd"

         << " pr0=" << RosPrintBvi(fPr0Last,8)

         << " r=" << rset << "," << brst

         << " cmd=" << MnemoPcmd(pcmd);


    if (pcmd == kPCMD_GETCMD && fPC_rdpcb > 0) { // if GETCMD and pdb loaded

      uint16_t func = fPcb[0] & kPC0_M_FUNC;

      lmsg << " fu=" << MnemoFunc(func);


      if (func == kFUNC_RMAL || func == kFUNC_WMAL || // if func with udbb

          func == kFUNC_RRF  || func == kFUNC_WRF ||

          func == kFUNC_RCTR || func == kFUNC_RCCTR ||

          func == kFUNC_RSID || func == kFUNC_WSID) {

        uint32_t udbb = 0777777;

        Wlist2UBAddr(&fPcb[1], udbb);

        lmsg << " udbb=" << RosPrintf(udbb&kUBA_M,"o0", 6);

      }

    }

    if (pcmd == kPCMD_PDMD && fPC_rdtxdsccur > 0) { // PDMD and txdsc ect loaded

      lmsg << " t" << RosPrintf(fTxRingIndex,"d0", 2)

           << ","  << RingDsc2OSEString(fTxDscCurPC,'-')

           << ","  << RingDsc2OSEString(fTxDscNxtPC,'-')

           << " r" << RosPrintf(fRxRingIndex,"d0", 2)

           << ","  << RingDsc2OSEString(fRxDscCurPC,'-')

           << ","  << RingDsc2OSEString(fRxDscNxtPC,'-');

    }

  }


  switch (pcmd) {

  case kPCMD_NOOP:                          // NOOP --------------------------

    fStats.Inc(kStatNPcmdNoop);

    return 0;                                 // fully handled in FPGA


  case kPCMD_GETPCBB:                       // GETPCBB -----------------------

    {

      fStats.Inc(kStatNPcmdGetpcbb);

      size_t ipr2 = cpu.AddRibr(clist, fBase+kPR2);

      size_t ipr3 = cpu.AddRibr(clist, fBase+kPR3);

      cpu.AddWibr(clist, fBase+kPR1, GetPr1());

      cpu.AddWibr(clist, fBase+kPR0, kPR0_M_DNI);

      Server().Exec(clist);

      fPcbb = ( uint32_t(clist[ipr2].Data()) |

               (uint32_t(clist[ipr3].Data())<<16)) & kUBA_M; // 17:01 valid!

      fPcbbValid = true;

      SetupPrimClist();

      if (fTraceLevel>0) {

        RlogMsg lmsg(LogFile());

        lmsg << "-I " << Name() << ": GETPCBB: " << RosPrintBvi(fPcbb,8,18);

      }

    }

    return 0;


  case kPCMD_GETCMD:                        // GETCMD ------------------------

    {

      fStats.Inc(kStatNPcmdGetcmd);

      bool ok = ExecGetcmd(clist);

      pr0out |= ok ? kPR0_M_DNI : kPR0_M_PCEI;

    }

    break;


  case kPCMD_SELFTST:                       // SELFTST -----------------------

    {

      fStats.Inc(kStatNPcmdSelftst);

      Reset();                                // handle like reset

      pr0out   |= kPR0_M_DNI;

    }

    return 0;


  case kPCMD_START:                         // START -------------------------

    {

      fStats.Inc(kStatNPcmdStart);

      if (fPr1State == kSTATE_RUN) {          // start while running is a noop

        pr0out |= kPR0_M_DNI;

        break;

      }

      if (fPr1State == kSTATE_READY && fRingValid) { // in _READY and ring ok

        SetRunning(true);

        pr0out |= kPR0_M_DNI;

      } else {

        pr0out |= kPR0_M_PCEI;

      }

    }

    break;


  case kPCMD_BOOT:                          // BOOT --------------------------

    {

      fStats.Inc(kStatNPcmdUimpl);            // not implemented ...

      pr0out |= kPR0_M_PCEI;

    }

    break;


  case kPCMD_PDMD:                          // PDMD --------------------------

    {

      fStats.Inc(kStatNPcmdPdmd);

      if (Running()) {

        StartTxRing(fTxDscCurPC, fTxDscNxtPC);

        StartRxRing(fRxDscCurPC, fRxDscNxtPC);

      }

      pr0out |= kPR0_M_DNI;

    }

    break;


  case kPCMD_HALT:                          // HALT --------------------------

    {

      if (fPr1Delua) {

        fStats.Inc(kStatNPcmdHalt);           // defined for DELUA

        SetRunning(false);

        fPr1State = kSTATE_PHALT;             // ends in dead end state

      } else {

        fStats.Inc(kStatNPcmdRsrvd);

      }

      pr0out |= kPR0_M_DNI;                 // always DNI it (is noop on DEUNA)

    }

    break;


  case kPCMD_STOP:                          // STOP --------------------------

    {

      fStats.Inc(kStatNPcmdStop);

      if (fPr1State == kSTATE_RUN) {          // stop if in _RUN, noop otherwise

        SetRunning(false);

      }

      pr0out |= kPR0_M_PCEI;

    }

    break;


  default:                                  // all others are reserved codes

    {

      fStats.Inc(kStatNPcmdRsrvd);

      pr0out |= kPR0_M_DNI;

    }

    break;

  }


  cpu.AddWibr(clist, fBase+kPR1, GetPr1());

  cpu.AddWibr(clist, fBase+kPR0, pr0out);

  Server().Exec(clist);

  return 0;

}


//--------------------------------------+-----------------------------------


void Rw11CntlDEUNA::ClearMacList()

{

  for (auto& mac : fMacList) mac = 0;

  fMacList[0] = fMacDefault;

  fMacList[1] = 0xffffffffffff;

  fMcastCnt = 0;

  return;

}


//--------------------------------------+-----------------------------------


void Rw11CntlDEUNA::ClearCtr()

{

  fCtrTimeCleared.GetClock(CLOCK_MONOTONIC);

  fCtrRxFra      = 0;

  fCtrRxFraMcast = 0;

  fCtrRxByt      = 0;

  fCtrRxBytMcast = 0;

  fCtrRxFraLoInt = 0;

  fCtrRxFraLoBuf = 0;

  fCtrTxFra      = 0;

  fCtrTxFraMcast = 0;

  fCtrTxByt      = 0;

  fCtrTxBytMcast = 0;

  fCtrTxFraAbort = 0;

  fCtrFraLoop    = 0;

  return;

}


//--------------------------------------+-----------------------------------


void Rw11CntlDEUNA::ClearStatus()

{

  fStatus = 0;                              // lsb is 0 anyway. so clear all

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::Reset()

{

  fRunning     = false;                     // end running

  StopTxRing();                             // run-down tx ring

  StopRxRing();                             // run-down rx ring

  fPcbbValid   = false;                     // clear state

  fPcbb        = 0;

  fRingValid   = false;

  fTxRingBase  = 0;

  fTxRingSize  = 0;

  fTxRingELen  = 0;

  fRxRingBase  = 0;

  fRxRingSize  = 0;

  fRxRingELen  = 0;

  fTxRingIndex = 0;

  fRxRingIndex = 0;

  fMacList[0]  = fMacDefault;

  fMcastCnt    = 0;

  fPr1Pcto     = false;

  fPr1State    = kSTATE_READY;

  SetupPrimClist();

  ClearStatus();

  ClearCtr();

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::SetRunning(bool run)

{

  if (fRunning == run) return;

  if (run) {                                // start

    if (! fRxPollTimer.IsOpen()) {            // start poll timer if needed

      fRxPollTimer.Open();

      Server().AddPollHandler([this](const pollfd& pfd)

                                { return RxPollHandler(pfd); },

                              fRxPollTimer.Fd(), POLLIN);

    }


    fRunning  = true;

    fPr1State = kSTATE_RUN;

    fTxRingIndex = 0;

    fTxBufOffset = 0;

    fRxRingIndex = 0;

    fRxBufOffset = 0;


    StartTxRing();

    StartRxRing();


  } else {                                  // stop

    fRunning  = false;

    StopTxRing();

    StopRxRing();

    fPr1State = kSTATE_READY;

  }


  SetupPrimClist();

  return;

}


//--------------------------------------+-----------------------------------

bool Rw11CntlDEUNA::ExecGetcmd(RlinkCommandList& clist)

{

  Rw11Cpu& cpu = Cpu();


  // FIXME_code: where is pcb read status checked ??

  if (fPC_rdpcb == 0) {                     // if pcb not available

    fPr1Pcto = true;

    return false;

  }


  uint16_t func = fPcb[0] & kPC0_M_FUNC;

  if (fPcb[0] & kPC0_M_MBZ) return false;


  uint32_t udbb;

  uint16_t pr2len;

  Wlist2UBAddrLen(&fPcb[1], udbb, pr2len);

  bool udbb_ok = (udbb & ~kUBA_M) == 0;


  switch (func) {

  case kFUNC_NOOP:                          // NOOP --------------------------

    fStats.Inc(kStatNFuncNoop);

    return true;


  case kFUNC_RDPA:                          // RDPA  -- read default mac -----

    {

      fStats.Inc(kStatNFuncRdpa);

      RethTools::Mac2WList(fMacDefault, &fPcb[1]);

      cpu.AddWMem(clist, fPcbb+2, &fPcb[1], 3, Rw11Cpu::kCPAH_M_UBM22, true);

      LogMacFunc("RDPA", fMacDefault);

      return true;

    }


  case kFUNC_RPA:                           // RPA -- read mac ---------------

    {

      fStats.Inc(kStatNFuncRpa);

      RethTools::Mac2WList(fMacList[0], &fPcb[1]);

      cpu.AddWMem(clist, fPcbb+2, &fPcb[1], 3, Rw11Cpu::kCPAH_M_UBM22, true);

      LogMacFunc("RPA", fMacList[0]);

      return true;

    }


  case kFUNC_WPA:                           // WPA -- write mac---------------

    {

      fStats.Inc(kStatNFuncWpa);

      uint64_t mac= RethTools::WList2Mac(&fPcb[1]);

      if (mac & 0x1) return false;              // lsb of MAC must be 0

      fMacList[0] = mac;

      LogMacFunc("RPA", fMacList[0]);

      return true;

    }


  case kFUNC_RMAL:                          // RMAL -- read mcast list -------

    {

      fStats.Inc(kStatNFuncRmal);

      if (!udbb_ok) return false;

      uint16_t mltlen = pr2len;

      if (mltlen > kDimMcast) return false;

      if (mltlen == 0) return true;

      uint16_t udb[3*kDimMcast];

      for (int i=0; i<mltlen; i++) {

        RethTools::Mac2WList(fMacList[2+i], &udb[3*i]);

      }

      LogMcastFunc("RMAL");


      RlinkCommandList clist1;

      cpu.AddWMem(clist1, udbb, udb, 3*mltlen, Rw11Cpu::kCPAH_M_UBM22, true);

      Server().Exec(clist1);

      // FIXME_code: handle access errors

      return true;

    }


  case kFUNC_WMAL:                          // WMAL -- write mcast list ------

    {

      fStats.Inc(kStatNFuncWmal);

      if (!udbb_ok) return false;

      uint16_t mltlen = pr2len;

      if (mltlen > kDimMcast) return false;

      fMcastCnt = 0;

      for (int i=0; i<kDimMcast; i++) fMacList[2+i] = 0;

      if (mltlen == 0) return true;


      uint16_t udb[3*kDimMcast];

      RlinkCommandList clist1;

      cpu.AddRMem(clist1, udbb, udb, 3*mltlen, Rw11Cpu::kCPAH_M_UBM22, true);

      Server().Exec(clist1);

      // FIXME_code: handle access errors

      for (int i=0; i<mltlen; i++) {

        uint64_t mac = RethTools::WList2Mac(&udb[3*i]);

        if (!(mac & 0x1)) return false;  // FIXME_code: check needed? DELUA ?

        fMacList[2+i] = mac;

      }

      fMcastCnt = mltlen;

      LogMcastFunc("WMAL");


      return true;

    }


  case kFUNC_RRF:                           // RRF -- read ring format -------

    {

      fStats.Inc(kStatNFuncRrf);

      // FIXME_code: get correct MBZ test !!

      if (!udbb_ok) return false;             // pdb[2] length ignored

      uint16_t udb[6];

      UBAddrLen2Wlist(&udb[0], fTxRingBase, fTxRingELen);

      udb[2] = fTxRingSize;

      UBAddrLen2Wlist(&udb[3], fRxRingBase, fRxRingELen);

      udb[5] = fRxRingSize;

      LogRingFunc("RRF");


      RlinkCommandList clist1;

      cpu.AddWMem(clist1, udbb, udb, 6, Rw11Cpu::kCPAH_M_UBM22, true);

      Server().Exec(clist1);

      // FIXME_code: handle access errors

      return true;

    }


  case kFUNC_WRF:                           // WRF -- write ring format ------

    {

      fStats.Inc(kStatNFuncWrf);

      if (!udbb_ok) return false;             // pdb[2] length ignored

      uint16_t udb[6];

      RlinkCommandList clist1;

      cpu.AddRMem(clist1, udbb, udb, 6, Rw11Cpu::kCPAH_M_UBM22, true);

      Server().Exec(clist1);

      // FIXME_code: handle access errors

      uint32_t txbase, rxbase;

      uint16_t txelen, rxelen;

      uint16_t txsize, rxsize;

      Wlist2UBAddrLen(&udb[0], txbase, txelen);

      if (txbase & ~kUBA_M) return false;

      txsize = udb[2];

      if (txsize <= 1) return false;

      Wlist2UBAddrLen(&udb[3], rxbase, rxelen);

      if (rxbase & ~kUBA_M) return false;

      rxsize = udb[5];

      if (rxsize <= 1) return false;

      fRingValid  = true;

      fTxRingBase = txbase;

      fTxRingELen = txelen;

      fTxRingSize = txsize;

      fRxRingBase = rxbase;

      fRxRingELen = rxelen;

      fRxRingSize = rxsize;

      LogRingFunc("WRF");

      return true;

    }


  case kFUNC_RCTR:                          // RCTR -- read counters ---------

  case kFUNC_RCCTR:                         // RCCTR -- read&clear counters --

    {

      fStats.Inc((func==kFUNC_RCCTR) ? kStatNFuncRcctr : kStatNFuncRctr);

      if ((!udbb_ok) || pr2len != 0) return false;  // pdb[2] length mbz

      uint16_t ctrlen = fPcb[3];

      if (ctrlen &0x1) return false;          // must be even

      if (ctrlen == 0) return true;           // nothing to do...

      uint16_t ctrmax = fPr1Delua ? kDimCtrDelua : kDimCtrDeuna;

      if (ctrlen > ctrmax) ctrlen = ctrmax;


      uint16_t udb[kDimCtr];

      for (auto& w : udb) w = 0;


      Rtime dt = Rtime(CLOCK_MONOTONIC) - fCtrTimeCleared;

      udb[ 0] = ctrlen;

      udb[ 1] = (dt.Sec() < 0xffff) ? uint16_t(dt.Sec()) : 0xffff;

      udb[ 2] =  fCtrRxFra      & 0xffff;

      udb[ 3] =  fCtrRxFra      >> 16;

      udb[ 4] =  fCtrRxFraMcast & 0xffff;

      udb[ 5] =  fCtrRxFraMcast >> 16;

      udb[ 8] =  fCtrRxByt      & 0xffff;

      udb[ 9] =  fCtrRxByt      >> 16;

      udb[10] =  fCtrRxBytMcast & 0xffff;

      udb[11] =  fCtrRxBytMcast >> 16;

      udb[12] =  fCtrRxFraLoInt;

      udb[13] =  fCtrRxFraLoBuf;

      udb[14] =  fCtrTxFra      & 0xffff;

      udb[15] =  fCtrTxFra      >> 16;

      udb[16] =  fCtrTxFraMcast & 0xffff;

      udb[17] =  fCtrTxFraMcast >> 16;

      udb[24] =  fCtrTxByt      & 0xffff;

      udb[25] =  fCtrTxByt      >> 16;

      udb[26] =  fCtrTxBytMcast & 0xffff;

      udb[27] =  fCtrTxBytMcast >> 16;

      udb[29] =  fCtrTxFraAbort;

      RlinkCommandList clist1;

      cpu.AddWMem(clist1, udbb, udb, ctrlen, Rw11Cpu::kCPAH_M_UBM22, true);

      Server().Exec(clist1);

      // FIXME_code: handle access errors

      if (func==kFUNC_RCCTR) ClearCtr();

      return true;

    }


  case kFUNC_RMODE:                         // RMODE -- read mode ------------

    {

      fStats.Inc(kStatNFuncRmode);

      fPcb[1] = fMode;

      cpu.AddWMem(clist, fPcbb+2, &fPcb[1], 1, Rw11Cpu::kCPAH_M_UBM22, true);

      LogFunc("RMODE", "mode", fMode);

      return true;

    }


  case kFUNC_WMODE:                         // WMODE -- write mode -----------

    {

      fStats.Inc(kStatNFuncWmode);

      uint16_t mbz = fPr1Delua ? kMODE_M_MBZ_DELUA : kMODE_M_MBZ_DEUNA;

      if (fPcb[1] & mbz) return false;

      fMode = fPcb[1];

      LogFunc("WMODE", "mode", fMode);

      return true;

    }


  case kFUNC_RSTAT:                         // RSTAT -- read status ----------

  case kFUNC_RCSTAT:                        // RCSTAT -- read&clear status ---

    {

      fStats.Inc((func==kFUNC_RCSTAT) ? kStatNFuncRcstat : kStatNFuncRstat);

      fPcb[1] = fStatus;

      fPcb[2] = Rtools::Bytes2Word(kDimMcast, fMcastCnt);

      fPcb[3] = fPr1Delua ? kDimCtrDelua : kDimCtrDeuna;

      cpu.AddWMem(clist, fPcbb+2, &fPcb[1], 3, Rw11Cpu::kCPAH_M_UBM22, true);

      LogFunc((func==kFUNC_RCSTAT) ? "RCSTAT" : "RSTAT",

              "stat", fStatus, "mltlen", fMcastCnt);

      if (func==kFUNC_RCSTAT) ClearStatus();

      return true;

    }


  case kFUNC_RSID:                          // RSID -- read system ID --------

    {

      fStats.Inc(kStatNFuncRsid);

      if ((!udbb_ok) || pr2len != 0) return false;  // pdb[2] length mbz

      uint16_t pltlen = fPcb[3];

      if (pltlen &0x1) return false;          // must be even

      if (pltlen == 0) return true;           // nothing to do...

      if (pltlen > kDimPlt) return false;     // PLTLEN to high is error


      uint16_t udb[kDimPlt];

      for (auto& w : udb) w = 0;


      // this follow DEUNA UG and DELUA UG (defaults are same for both)

      // and the simh pdp11_xu.c implementation

      udb[11] = 0x260;                      // type

      udb[12] = 28;                         // ccount (+parameters... NI)

      udb[13] = 7;                          // code

      udb[14] = 0;                          // recnum

                                            // mop information

      udb[15] = 1;                          // mvtype

      udb[16] = 0x0303;                     // mvver + mvlen

      udb[17] = 0;                          // mvueco + mveco

                                            // function information

      udb[18] = 2;                          // ftype

      udb[19] = 0x0502;                     // fval1 + flen

      udb[20] = 0x0700;                     // hatype<07:00> + fval2

      udb[21] = 0x0600;                     // halen + hatype<15:08>

                                            // built-in MAC address

      RethTools::Mac2WList(fMacList[0], &udb[21]); // HA

      udb[24] = 0x64;                       // dtype

      udb[25] = (11 << 8) + 1;              // dvalue + dlen

      RlinkCommandList clist1;

      cpu.AddWMem(clist1, udbb, udb, pltlen, Rw11Cpu::kCPAH_M_UBM22, true);

      Server().Exec(clist1);

      // FIXME_code: handle access errors

      return true;

    }


  case kFUNC_WSID:                          // WSID -- write system ID -------

    {

      fStats.Inc(kStatNFuncWsid);

      return false;                         // currently not implemented

    }


  default:

    fStats.Inc(kStatNFuncUimpl);

    return false;

  }

  return false;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::SetupPrimClist()

{

  Rw11Cpu& cpu  = Cpu();


  fPrimClist.Clear();

  fPrimClist.AddAttn();

  fPC_rdpr0      = cpu.AddRibr(fPrimClist, fBase+kPR0);

  fPC_rdpcb      = 0;

  fPC_lapcb      = 0;

  fPC_rdtxdsccur = 0;

  fPC_latxdsccur = 0;

  fPC_rdtxdscnxt = 0;

  fPC_latxdscnxt = 0;

  fPC_rdrxdsccur = 0;

  fPC_larxdsccur = 0;

  fPC_rdrxdscnxt = 0;

  if (!fPcbbValid) return;

  fPC_rdpcb = cpu.AddRMem(fPrimClist, fPcbb, fPcb, 4,

                          Rw11Cpu::kCPAH_M_UBM22, true);

  fPC_lapcb = fPrimClist.AddLabo();

  if (!Running()) return;


  // Note: the memory addresses will be set before each usage with ModLalh()

  //       that's why the initial memory address is set as kUBA_M (end of ubmap)

  fPC_rdtxdsccur = cpu.AddRMem(fPrimClist, kUBA_M, fTxDscCurPC, 3,

                               Rw11Cpu::kCPAH_M_UBM22, true);

  fPC_latxdsccur = fPrimClist.AddLabo();


  fPC_rdtxdscnxt = cpu.AddRMem(fPrimClist, kUBA_M, fTxDscNxtPC, 3,

                               Rw11Cpu::kCPAH_M_UBM22, true);

  fPC_latxdscnxt = fPrimClist.AddLabo();


  fPC_rdrxdsccur = cpu.AddRMem(fPrimClist, kUBA_M, fRxDscCurPC, 3,

                               Rw11Cpu::kCPAH_M_UBM22, true);

  fPC_larxdsccur = fPrimClist.AddLabo();


  fPC_rdrxdscnxt = cpu.AddRMem(fPrimClist, kUBA_M, fRxDscCurPC, 3,

                               Rw11Cpu::kCPAH_M_UBM22, true);

  return;

}


//--------------------------------------+-----------------------------------


uint16_t Rw11CntlDEUNA::GetPr1() const

{

  uint16_t pr1 = fPr1State;

  if (fPr1Pcto)  pr1 |= kPR1_M_PCTO;

  if (fPr1Delua) {

    pr1 |= kPR1_M_DELUA;

  } else {

    if (!fspUnit[0]->HasVirt()) {

      pr1 |= kPR1_M_XPWR | kPR1_M_ICAB;

    }

  }

  return pr1;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::StartTxRing()

{

  RlinkCommandList clist;

  uint16_t txdsccur[4];

  uint16_t txdscnxt[4];

  Cpu().AddRMem(clist, TxRingDscAddr(fTxRingIndex),

                txdsccur, 3, Rw11Cpu::kCPAH_M_UBM22, true);

  Cpu().AddRMem(clist, TxRingDscAddr(TxRingIndexNext()),

                txdscnxt, 3, Rw11Cpu::kCPAH_M_UBM22, true);

  Server().Exec(clist);

  // FIXME_code: check dsc read errors !

  StartTxRing(txdsccur, txdscnxt);

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::StartTxRing(const uint16_t dsccur[4],

                                const uint16_t dscnxt[4])

{

  if (fTxRingState != kStateTxIdle) return;


  SetRingDsc(fTxDscCur, dsccur);

  SetRingDsc(fTxDscNxt, dscnxt);


  if (fTxDscCurPC[2] & kTXR2_M_OWN) {       // pending tx frames ?

    fTxRingState = kStateTxBusy;

    Server().QueueAction([this](){ return TxRingHandler(); });

  }

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::StopTxRing()

{

  fTxRingState = kStateTxIdle;

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::StartRxRing()

{

  RlinkCommandList clist;

  uint16_t rxdsccur[4];

  uint16_t rxdscnxt[4];

  Cpu().AddRMem(clist, RxRingDscAddr(fRxRingIndex),

                rxdsccur, 3, Rw11Cpu::kCPAH_M_UBM22, true);

  Cpu().AddRMem(clist, RxRingDscAddr(RxRingIndexNext()),

                rxdscnxt, 3, Rw11Cpu::kCPAH_M_UBM22, true);

  Server().Exec(clist);

  // FIXME_code: check dsc read errors !

  StartRxRing(rxdsccur, rxdscnxt);

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::StartRxRing(const uint16_t dsccur[4],

                                const uint16_t dscnxt[4])

{

  if (fRxRingState != kStateRxIdle) return;


  SetRingDsc(fRxDscCur, dsccur);

  SetRingDsc(fRxDscNxt, dscnxt);


  if (!fRxBufQueue.empty() &&               // if pending rx frames

      fRxDscCur[2] & kRXR2_M_OWN) {         // and buffer available

    fRxRingState = kStateRxBusy;

    Server().QueueAction([this](){ return RxRingHandler(); });

  }

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::StopRxRing()

{

  if (fRxRingState == kStateRxPoll) fRxPollTimer.Cancel();

  fRxRingState = kStateRxIdle;

  return;

}

//--------------------------------------+-----------------------------------

int Rw11CntlDEUNA::TxRingHandler()

{

  fTxRingState = kStateTxIdle;              // expect quit

  if (!Running()) return 0;                   // quit if not running


  RlinkCommandList clist;

  Rw11Cpu& cpu  = Cpu();

  Rw11UnitDEUNA& unit = *fspUnit[0];


  if (!(fTxDscCur[2] & kTXR2_M_OWN)) return 0; // FIXME_code: shouldn't happen !

  // FIXME_code: quit if ring bad, not attached,...


  LogRingInfo('t','<');                     // log initial ring dsc state


  if (fTxBufOffset == 0) {                  // new frame processed

    fTxBuf.Clear();                           // clear buffer

    fTxBuf.SetTime();                         // set timestamp

  }


  // clear OWN+flags, keep SEGB,STF,ENF

  fTxDscCur[2] &= kTXR2_M_SEGB|kTXR2_M_STF|kTXR2_M_ENF;

  fTxDscCur[3]  = 0;


  uint16_t stat   = 0;

  uint16_t pr0out = 0;


  uint16_t slen = fTxDscCur[0];

  uint32_t segb = uint32_t(fTxDscCur[1]) | uint32_t(fTxDscCur[2] & 0xff)<<16;

  if (segb & ~kUBA_M) stat |= kSTAT_M_TRNG; // FIXME_code: see MBZ comment above


  uint16_t tsize = slen;

  if (tsize > RethBuf::kMaxSize) {

    tsize = RethBuf::kMaxSize;

    fTxDscCur[3] |= kTXR3_M_BUFL;           // FIXME_code: is that correct ?

  }


  // read data

  // FIXME_code: handle odd base !!

  cpu.AddRMem(clist, segb, fTxBuf.Buf16(), (tsize+1)/2,

              Rw11Cpu::kCPAH_M_UBM22, true);

  Server().Exec(clist);

  // FIXME_code: handle errors !!


  fTxBuf.SetSize(tsize);                    // FIXME_code: handle chunks !


  clist.Clear();


  // update current dsc

  cpu.AddWMem(clist, TxRingDscAddr(fTxRingIndex)+4, &fTxDscCur[2], 2,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();


  // re-read next dsc; and read next-next dsc

  uint16_t dsccurnew[4];

  uint16_t dscnxtnew[4];

  cpu.AddRMem(clist, TxRingDscAddr(TxRingIndexNext(1)), dsccurnew, 3,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();

  cpu.AddRMem(clist, TxRingDscAddr(TxRingIndexNext(2)), dscnxtnew, 3,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();


  // signal frame done

  pr0out |= kPR0_M_TXI;

  cpu.AddWibr(clist, fBase+kPR0, pr0out);


  // final frame handling

  fTxBuf.SetMacSource(fMacList[0]);         // set source address

  if (fTxBuf.Size() < RethBuf::kMinSize) {  // pad if to small

    ::memset(fTxBuf.Buf8()+fTxBuf.Size(), 0, RethBuf::kMinSize-fTxBuf.Size());

    fTxBuf.SetSize(RethBuf::kMinSize);

    fStats.Inc(kStatNTxFraPad);

    if (!(fMode&kMODE_M_TPAD)) {            // runt error unless TPAD active

      fTxDscCur[3] |= kTXR3_M_BUFL;

    }

  }


  // check for 'station match'

  uint64_t macdst = fTxBuf.MacDestination();

  int matchdst = MacFilter(macdst);

  if (matchdst > 0) {

    fTxDscCur[2] |= kTXR2_M_MTCH;

  }


  UpdateStat32(fCtrTxFra, kStatNTxFra);

  UpdateStat32(fCtrTxByt, kStatNTxByt, fTxBuf.Size());

  if (fTxBuf.IsMcast()) {                   // Mcast includes Bcast !

    UpdateStat32(fCtrTxFraMcast, kStatNTxFraMcast);

    UpdateStat32(fCtrTxBytMcast, kStatNTxBytMcast, fTxBuf.Size());

    if (fTxBuf.IsBcast()) {

      fStats.Inc(kStatNTxFraBcast);

    }

  }


  if (fTraceLevel>2) {

    RlogMsg lmsg(LogFile());

    std::ostringstream sos;

    fTxBuf.Dump(sos, 4, "fTxBuf: ");

    lmsg << sos.str();

  }


  LogFrameInfo('t', fTxBuf);               // log transmitted frame

  if (unit.HasVirt()) {                    //  attached ?

    RerrMsg emsg;

    unit.Virt().Snd(fTxBuf, emsg);

    // FIXME_code: error handling

  }


  LogRingInfo('t','>');                    // log final ring dsc state

  Server().Exec(clist);

  // FIXME_code: handle errors


  // push ring index, update current and next dsc

  fTxRingIndex = TxRingIndexNext();

  SetRingDsc(fTxDscCur, dsccurnew);

  SetRingDsc(fTxDscNxt, dscnxtnew);


  // now decide whether to idle or continue

  if (!(fTxDscCur[2] & kTXR2_M_OWN)) return 0; // quit if nothing to do


  fTxRingState = kStateTxBusy;              // otherwise continue

  return 1;

}


//--------------------------------------+-----------------------------------

int Rw11CntlDEUNA::RxRingHandler()

{

  fRxRingState = kStateRxIdle;

  if (!Running())  return 0;                // quit if not running


  RlinkCommandList clist;

  Rw11Cpu& cpu  = Cpu();


  if (!(fRxDscCur[2] & kRXR2_M_OWN)) return 0; // FIXME_code: shouldn't happen !


  if (fRxBufOffset == 0) {                  // new frame needed

    if (fRxBufQueue.empty()) return 0;        // quit if none available

    fRxBufCurr = fRxBufQueue.front();

    fRxBufQueue.pop_front();

  }

  RethBuf& ebuf = *fRxBufCurr;


  if (true && ebuf.Size() < RethBuf::kMinSize) { // pad if ena

    ::memset(ebuf.Buf8()+ebuf.Size(), 0, RethBuf::kMinSize-ebuf.Size());

    ebuf.SetSize(RethBuf::kMinSize);

    fStats.Inc(kStatNRxFraPad);

  }


  LogRingInfo('r','<');                     // log initial ring dsc state

  LogFrameInfo('e', ebuf);                  // log reveived frame


  // FIXME_code: this also clears the MBZ areas !! handle this correctly

  // clear OWN+flags, keep SEGB

  fRxDscCur[2] &= kRXR2_M_SEGB;

  fRxDscCur[3]  = 0;


  uint16_t stat   = 0;

  uint16_t pr0out = 0;


  uint16_t slen = fRxDscCur[0];

  uint32_t segb = uint32_t(fRxDscCur[1]) | uint32_t(fRxDscCur[2] & 0xff)<<16;

  if (segb & ~kUBA_M) stat |= kSTAT_M_RRNG; // FIXME_code: see MBZ comment above


  uint16_t tsize = ebuf.Size();


  if (ebuf.Size() > slen) {

    tsize = slen;

    fRxDscCur[3] |= kRXR3_M_BUFL;

  }


  // Note: the DEUNA returns in the rx descriptor the frame length including

  //       the CRC length (4 bytes) !! But apparently does not transfer the

  //       CRC, at least in normal mode !! See comments in simh pdp11_xu.c.

  fRxDscCur[2] |= kRXR2_M_STF | kRXR2_M_ENF;

  fRxDscCur[3] |= tsize+RethBuf::kCrcSize;


  // write data

  cpu.AddWMem(clist, segb, ebuf.Buf16(), (tsize+1)/2,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();

  // update current dsc

  cpu.AddWMem(clist, RxRingDscAddr(fRxRingIndex)+4, &fRxDscCur[2], 2,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();


  // re-read next dsc; and read next-next dsc

  uint16_t dsccurnew[4];

  uint16_t dscnxtnew[4];

  cpu.AddRMem(clist, RxRingDscAddr(RxRingIndexNext(1)), dsccurnew, 3,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();

  cpu.AddRMem(clist, RxRingDscAddr(RxRingIndexNext(2)), dscnxtnew, 3,

              Rw11Cpu::kCPAH_M_UBM22, true);

  clist.AddLabo();


  // signal frame done

  pr0out |= kPR0_M_RXI;

  cpu.AddWibr(clist, fBase+kPR0, pr0out);


  UpdateStat32(fCtrRxFra, kStatNRxFra);

  UpdateStat32(fCtrRxByt, kStatNRxByt, ebuf.Size());

  if (ebuf.IsMcast()) {                   // Mcast includes Bcast !

    UpdateStat32(fCtrRxFraMcast, kStatNRxFraMcast);

    UpdateStat32(fCtrRxBytMcast, kStatNRxBytMcast, ebuf.Size());

    if (ebuf.IsBcast()) {

      fStats.Inc(kStatNRxFraBcast);

    }

  }


  LogRingInfo('r','>');                    // log final ring dsc state

  Server().Exec(clist);

  // FIXME_code: handle errors


  // push ring index, update current and next dsc

  fRxRingIndex = RxRingIndexNext();

  SetRingDsc(fRxDscCur, dsccurnew);

  SetRingDsc(fRxDscNxt, dscnxtnew);


  // now decide whether to idle, continue, or poll

  if (fRxBufQueue.empty()) return 0;        // quit if nothing to do

  if (!(fRxDscCur[2] & kRXR2_M_OWN)) {      // no free buffer

    fRxPollTimer.SetRelative(fRxPollTime);

    fRxRingState = kStateRxPoll;              // activate timer

    return 0;

  }


  fRxRingState = kStateRxBusy;              // otherwise continue

  return 1;

}


//--------------------------------------+-----------------------------------

int Rw11CntlDEUNA::RxPollHandler(const pollfd& pfd)

{

  // bail-out and cancel handler if poll returns an error event

  if (pfd.revents & (~pfd.events)) return -1;


  uint64_t cnt = fRxPollTimer.Read();       // harvest expiration count

  if (!Running() ||                         // if not running

      fRxRingState != kStateRxPoll ||       // if not polling

      !cnt) return 0;                       // if not expired -> quit


  fRxRingState = kStateRxIdle;              // end poll

  StartRxRing();                            // re-start rx ring


  return 0;

}


//--------------------------------------+-----------------------------------

int Rw11CntlDEUNA::MacFilter(uint64_t mac)

{

  int maxind = 2 + fMcastCnt;

  for (int i=0; i<maxind; i++) {

    if (fMacList[i] == mac) return i;

  }

  return -1;

}

//--------------------------------------+-----------------------------------


void Rw11CntlDEUNA::UpdateStat16(uint32_t& stat, size_t ind, uint32_t inc)

{

  fStats.Inc(ind, inc);

  stat += inc;

  if (stat < inc || stat > 0xffff) stat = 0xffff;

}


//--------------------------------------+-----------------------------------


void Rw11CntlDEUNA::UpdateStat32(uint32_t& stat, size_t ind, uint32_t inc)

{

  fStats.Inc(ind, inc);

  stat += inc;

  if (stat < inc) stat = 0xffffffff;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::LogMacFunc(const char* cmd, uint64_t mac)

{

  if (fTraceLevel == 0) return;

  RlogMsg lmsg(LogFile());

  lmsg << "-I " << Name() << ": " << cmd << ": " << RethTools::Mac2String(mac);

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::LogMcastFunc(const char* cmd)

{

  if (fTraceLevel == 0) return;

  RlogMsg lmsg(LogFile());

  lmsg << "-I " << Name() << ": " << cmd << ": mltlen=" << fMcastCnt;

  for (int i=0; i<fMcastCnt; i++) {

    lmsg << "\n        " << RethTools::Mac2String(fMacList[2+i]);

  }

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::LogRingFunc(const char* cmd)

{

  if (fTraceLevel == 0) return;

  RlogMsg lmsg(LogFile());

  lmsg << "-I " << Name() << ": " << cmd << ":"

       << " tx base=" << RosPrintBvi(fTxRingBase,8,18)

       << " size=" << RosPrintf(fTxRingSize, "d", 2)

       << " elen=" << RosPrintf(fTxRingELen, "d", 2)

       << "; rx base=" << RosPrintBvi(fRxRingBase,8,18)

       << " size=" << RosPrintf(fRxRingSize, "d", 2)

       << " elen=" << RosPrintf(fRxRingELen, "d", 2);

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::LogFunc(const char* cmd, const char* tag1, uint16_t val1,

                            const char* tag2, uint16_t val2)

{

  if (fTraceLevel == 0) return;

  RlogMsg lmsg(LogFile());

  lmsg << "-I " << Name() << ": " << cmd << ": "

       << tag1 << "=" << RosPrintBvi(val1,8);

  if (tag2) lmsg << tag2 << "=" << RosPrintBvi(val2,8);

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::LogRingInfo(char rxtx, char rw)

{

  if (fTraceLevel == 0) return;


  bool tx = (rxtx == 't');

  uint16_t  rind = tx ? fTxRingIndex : fRxRingIndex;

  uint16_t* rdsc = tx ? fTxDscCur    : fRxDscCur;


  RlogMsg lmsg(LogFile());

  lmsg << "-I " << Name() << ": " << rxtx << "xr "

       << rxtx << RosPrintf(rind,"d0", 2) << " " << rw

       << " " << RingDsc2String(rdsc, rxtx);

  return;

}


//--------------------------------------+-----------------------------------

void Rw11CntlDEUNA::LogFrameInfo(char rxtx, const RethBuf& buf)

{

  if (fTraceLevel == 0) return;


  bool tx = (rxtx == 't');

  RlogMsg lmsg(LogFile());

  lmsg << "-I " << Name() << ":" << (tx ? " snd " : " rcv ") << buf.FrameInfo();

  return;

}


//--------------------------------------+-----------------------------------


std::string Rw11CntlDEUNA::RingDsc2String(const uint16_t dsc[4], char rxtx)

{

  std::ostringstream sos;

  uint32_t segb = uint32_t(dsc[1]) + (uint32_t(dsc[2] & kTXR2_M_SEGB)<<16);

  uint16_t mlen = dsc[3] & kRXR3_M_MLEN;

  sos << RosPrintf(dsc[0],"d", 4)

      << ","  << RosPrintBvi(segb, 8, 18)

      << ","  << RosPrintf(mlen,"d", 4)

      << "; " << RosPrintBvi(uint16_t(dsc[2]>>8), 2, 8)

      << ","  << RosPrintBvi(uint16_t(dsc[3]>>12), 2, 4) << ": ";


  sos << RingDsc2OSEString(dsc);


  if (dsc[2] & kTXR2_M_ERRS) sos << " errs";

  if (rxtx == 't') {

    if (dsc[2] & kTXR2_M_MTCH) sos << " mtch";

    if (dsc[2] & kTXR2_M_MORE) sos << " more";

    if (dsc[2] & kTXR2_M_ONE)  sos << " one";

    if (dsc[2] & kTXR2_M_DEF)  sos << " def";

    sos << ",";

    if (dsc[2] & kTXR3_M_BUFL) sos << " bufl";

    if (dsc[2] & kTXR3_M_UBTO) sos << " ubto";

    if (dsc[2] & kTXR3_M_LCOL) sos << " lcol";

    if (dsc[2] & kTXR3_M_LCAR) sos << " lcar";

    if (dsc[2] & kTXR3_M_RTRY) sos << " rtry";

  } else {

    if (dsc[2] & kRXR2_M_FRAM) sos << " fram";

    if (dsc[2] & kRXR2_M_OFLO) sos << " oflo";

    if (dsc[2] & kRXR2_M_CRC)  sos << " crc";

    sos << ",";

    if (dsc[2] & kRXR3_M_BUFL) sos << " bufl";

    if (dsc[2] & kRXR3_M_UBTO) sos << " ubto";

    if (dsc[2] & kRXR3_M_NCHN) sos << " nchn";

    if (dsc[2] & kRXR3_M_OVRN) sos << " ovrn";

  }


  return sos.str();

}


//--------------------------------------+-----------------------------------


std::string Rw11CntlDEUNA::RingDsc2OSEString(const uint16_t dsc[4], char fill)

{

  char res[4] = {fill,fill,fill,0};

  if (dsc[2] & kTXR2_M_OWN) res[0] = 'O';

  if (dsc[2] & kTXR2_M_STF) res[1] = 'S';

  if (dsc[2] & kTXR2_M_ENF) res[2] = 'E';

  return string(res);

}


} // end namespace Retro

RethTools.hpp

Rexception.hpp

RlogMsg.hpp

RosFill.hpp

RosPrintBvi.hpp

RosPrintf.hpp

Rtools.hpp

Rw11CntlDEUNA.hpp

Retro::RerrMsg
FIXME_docs.
Definition: RerrMsg.hpp:25

Retro::RethBuf
FIXME_docs.
Definition: RethBuf.hpp:27

Retro::RethBuf::SetTime
void SetTime()
FIXME_docs.
Definition: RethBuf.ipp:42

Retro::RethBuf::IsMcast
bool IsMcast() const
FIXME_docs.
Definition: RethBuf.ipp:158

Retro::RethBuf::kCrcSize
static const size_t kCrcSize
size of ethernet CRC
Definition: RethBuf.hpp:70

Retro::RethBuf::kMinSize
static const size_t kMinSize
min ethernet frame size
Definition: RethBuf.hpp:69

Retro::RethBuf::IsBcast
bool IsBcast() const
FIXME_docs.
Definition: RethBuf.ipp:166

Retro::RethBuf::Dump
void Dump(std::ostream &os, int ind=0, const char *text=0, int detail=0) const
FIXME_docs.
Definition: RethBuf.cpp:102

Retro::RethBuf::SetMacSource
void SetMacSource(uint64_t mac)
FIXME_docs.
Definition: RethBuf.ipp:133

Retro::RethBuf::Buf8
const uint8_t * Buf8() const
FIXME_docs.
Definition: RethBuf.ipp:76

Retro::RethBuf::MacDestination
uint64_t MacDestination() const
FIXME_docs.
Definition: RethBuf.ipp:142

Retro::RethBuf::kMaxSize
static const size_t kMaxSize
max ethernet frame size
Definition: RethBuf.hpp:68

Retro::RethBuf::Buf16
const uint16_t * Buf16() const
FIXME_docs.
Definition: RethBuf.ipp:84

Retro::RethBuf::pbuf_t
std::shared_ptr< RethBuf > pbuf_t
Definition: RethBuf.hpp:29

Retro::RethBuf::FrameInfo
std::string FrameInfo() const
FIXME_docs.
Definition: RethBuf.cpp:89

Retro::RethBuf::SetSize
void SetSize(uint16_t size)
FIXME_docs.
Definition: RethBuf.ipp:33

Retro::RethBuf::Size
uint16_t Size() const
FIXME_docs.
Definition: RethBuf.ipp:60

Retro::RethBuf::Clear
void Clear()
FIXME_docs.
Definition: RethBuf.ipp:24

Retro::Rexception
FIXME_docs.
Definition: Rexception.hpp:29

Retro::Rfd::IsOpen
bool IsOpen() const
FIXME_docs.
Definition: Rfd.ipp:28

Retro::Rfd::Fd
int Fd() const
FIXME_docs.
Definition: Rfd.ipp:20

Retro::RlinkCommandList
FIXME_docs.
Definition: RlinkCommandList.hpp:40

Retro::RlinkCommandList::AddAttn
size_t AddAttn()
FIXME_docs.
Definition: RlinkCommandList.cpp:184

Retro::RlinkCommandList::Clear
void Clear()
FIXME_docs.
Definition: RlinkCommandList.cpp:308

Retro::RlinkCommandList::AddLabo
size_t AddLabo()
FIXME_docs.
Definition: RlinkCommandList.cpp:174

Retro::RlinkServer::AddAttnHandler
void AddAttnHandler(attnhdl_t &&attnhdl, uint16_t mask, void *cdata=nullptr)
FIXME_docs.
Definition: RlinkServer.cpp:136

Retro::RlinkServer::QueueAction
void QueueAction(actnhdl_t &&actnhdl)
FIXME_docs.
Definition: RlinkServer.cpp:206

Retro::RlinkServer::GetAttnInfo
void GetAttnInfo(AttnArgs &args, RlinkCommandList &clist)
FIXME_docs.
Definition: RlinkServer.cpp:159

Retro::RlinkServer::Exec
bool Exec(RlinkCommandList &clist, RerrMsg &emsg)
FIXME_docs.
Definition: RlinkServer.ipp:60

Retro::RlinkServer::AddPollHandler
void AddPollHandler(pollhdl_t &&pollhdl, int fd, short events=POLLIN)
FIXME_docs.
Definition: RlinkServer.cpp:217

Retro::RlogMsg
FIXME_docs.
Definition: RlogMsg.hpp:24

Retro::RosFill
I/O appicator to generate fill characters.
Definition: RosFill.hpp:24

Retro::RosPrintBvi
FIXME_docs.
Definition: RosPrintBvi.hpp:23

Retro::Rstats::Inc
void Inc(size_t ind, double val=1.)
FIXME_docs.
Definition: Rstats.ipp:29

Retro::Rstats::Define
void Define(size_t ind, const std::string &name, const std::string &text)
FIXME_docs.
Definition: Rstats.cpp:72

Retro::Rtime
FIXME_docs.
Definition: Rtime.hpp:25

Retro::Rtime::Sec
time_t Sec() const
FIXME_docs.
Definition: Rtime.ipp:109

Retro::Rtime::IsPositive
bool IsPositive() const
FIXME_docs.
Definition: Rtime.ipp:93

Retro::Rtime::GetClock
void GetClock(clockid_t clkid)
FIXME_docs.
Definition: Rtime.cpp:41

Retro::Rtime::Age
double Age(clockid_t clkid) const
FIXME_docs.
Definition: Rtime.cpp:72

Retro::RtimerFd::Read
uint64_t Read()
FIXME_docs.
Definition: RtimerFd.cpp:114

Retro::RtimerFd::Cancel
void Cancel()
FIXME_docs.
Definition: RtimerFd.cpp:87

Retro::RtimerFd::Open
void Open(clockid_t clkid=CLOCK_MONOTONIC)
FIXME_docs.
Definition: RtimerFd.cpp:51

Retro::RtimerFd::SetRelative
void SetRelative(const Rtime &dt)
FIXME_docs.
Definition: RtimerFd.cpp:65

Retro::Rw11CntlBase
Implemenation (inline) of Rw11CntlBase.
Definition: Rw11CntlBase.hpp:30

Retro::Rw11CntlBase::Dump
virtual void Dump(std::ostream &os, int ind=0, const char *text=0, int detail=0) const
FIXME_docs.
Definition: Rw11CntlBase.ipp:87

Retro::Rw11CntlBase< Rw11UnitDEUNA, 1 >::fspUnit
std::shared_ptr< Rw11UnitDEUNA > fspUnit[NU]
Definition: Rw11CntlBase.hpp:48

Retro::Rw11CntlDEUNA::kMODE_M_MBZ_DEUNA
static const uint16_t kMODE_M_MBZ_DEUNA
MBZ bit:10,8:4,1.
Definition: Rw11CntlDEUNA.hpp:162

Retro::Rw11CntlDEUNA::kSTAT_M_RRNG
static const uint16_t kSTAT_M_RRNG
RRNG: rx ring error.
Definition: Rw11CntlDEUNA.hpp:146

Retro::Rw11CntlDEUNA::kTXR2_M_SEGB
static const uint16_t kTXR2_M_SEGB
SEGB: msg of seg base.
Definition: Rw11CntlDEUNA.hpp:173

Retro::Rw11CntlDEUNA::UnitSetup
virtual void UnitSetup(size_t ind)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:363

Retro::Rw11CntlDEUNA::kPR0_M_RSET
static const uint16_t kPR0_M_RSET
RSET: sw reset.
Definition: Rw11CntlDEUNA.hpp:86

Retro::Rw11CntlDEUNA::kSTATE_PHALT
static const uint16_t kSTATE_PHALT
port halted
Definition: Rw11CntlDEUNA.hpp:118

Retro::Rw11CntlDEUNA::kFUNC_WSID
static const uint16_t kFUNC_WSID
WSID: write system id.
Definition: Rw11CntlDEUNA.hpp:139

Retro::Rw11CntlDEUNA::fTxRingELen
uint16_t fTxRingELen
tx ring entry length
Definition: Rw11CntlDEUNA.hpp:353

Retro::Rw11CntlDEUNA::RingDsc2OSEString
static std::string RingDsc2OSEString(const uint16_t dsc[4], char fill=' ')
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1858

Retro::Rw11CntlDEUNA::kSTAT_M_TMOT
static const uint16_t kSTAT_M_TMOT
TMOT: UNIBUS timeout.
Definition: Rw11CntlDEUNA.hpp:145

Retro::Rw11CntlDEUNA::kSTAT_M_MERR
static const uint16_t kSTAT_M_MERR
MERR: multiple errors.
Definition: Rw11CntlDEUNA.hpp:142

Retro::Rw11CntlDEUNA::fRunning
bool fRunning
in kSTATE_RUN and active
Definition: Rw11CntlDEUNA.hpp:364

Retro::Rw11CntlDEUNA::kPC0_M_FUNC
static const uint16_t kPC0_M_FUNC
FUNC: function code.
Definition: Rw11CntlDEUNA.hpp:121

Retro::Rw11CntlDEUNA::kFUNC_RMAL
static const uint16_t kFUNC_RMAL
RMAL: read mcast MAC list.
Definition: Rw11CntlDEUNA.hpp:128

Retro::Rw11CntlDEUNA::Wlist2UBAddrLen
void Wlist2UBAddrLen(const uint16_t wlist[2], uint32_t &addr, uint16_t &len)
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:48

Retro::Rw11CntlDEUNA::kPR0_M_RXI
static const uint16_t kPR0_M_RXI
RXI: receive rung intr.
Definition: Rw11CntlDEUNA.hpp:78

Retro::Rw11CntlDEUNA::fCtrTxFraAbort
uint32_t fCtrTxFraAbort
ctr: xmit aborted frames
Definition: Rw11CntlDEUNA.hpp:398

Retro::Rw11CntlDEUNA::fRxRingState
enum s_rx fRxRingState
rx ring handler busy
Definition: Rw11CntlDEUNA.hpp:378

Retro::Rw11CntlDEUNA::Config
void Config(const std::string &name, uint16_t base, int lam)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:323

Retro::Rw11CntlDEUNA::kTXR3_M_LCAR
static const uint16_t kTXR3_M_LCAR
LCAR: lost carrier.
Definition: Rw11CntlDEUNA.hpp:178

Retro::Rw11CntlDEUNA::kRXR3_M_MLEN
static const uint16_t kRXR3_M_MLEN
MLEN: message length.
Definition: Rw11CntlDEUNA.hpp:194

Retro::Rw11CntlDEUNA::RingDsc2String
static std::string RingDsc2String(const uint16_t dsc[4], char rxtx)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1816

Retro::Rw11CntlDEUNA::AttnHandler
int AttnHandler(RlinkServer::AttnArgs &args)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:718

Retro::Rw11CntlDEUNA::kRXR2_M_ERRS
static const uint16_t kRXR2_M_ERRS
ERRS: error summary.
Definition: Rw11CntlDEUNA.hpp:183

Retro::Rw11CntlDEUNA::Wlist2UBAddr
void Wlist2UBAddr(const uint16_t wlist[2], uint32_t &addr)
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:40

Retro::Rw11CntlDEUNA::kSTATE_NHALT
static const uint16_t kSTATE_NHALT
ni halted
Definition: Rw11CntlDEUNA.hpp:116

Retro::Rw11CntlDEUNA::ClearStatus
void ClearStatus()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:961

Retro::Rw11CntlDEUNA::kPCMD_GETCMD
static const uint16_t kPCMD_GETCMD
GETCMD: get command.
Definition: Rw11CntlDEUNA.hpp:97

Retro::Rw11CntlDEUNA::SetupPrimClist
void SetupPrimClist()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1308

Retro::Rw11CntlDEUNA::fRxDscNxt
uint16_t fRxDscNxt[4]
rx nxt ring dsc
Definition: Rw11CntlDEUNA.hpp:380

Retro::Rw11CntlDEUNA::kMODE_M_INTL
static const uint16_t kMODE_M_INTL
INTL: int loopback(DELUA)
Definition: Rw11CntlDEUNA.hpp:158

Retro::Rw11CntlDEUNA::kUBAODD_M
static const uint32_t kUBAODD_M
bits of odd unibus address
Definition: Rw11CntlDEUNA.hpp:197

Retro::Rw11CntlDEUNA::ExecGetcmd
bool ExecGetcmd(RlinkCommandList &clist)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1031

Retro::Rw11CntlDEUNA::kPR0_V_PCMDBP
static const uint16_t kPR0_V_PCMDBP
PCMDBP: pcmd busy prot.
Definition: Rw11CntlDEUNA.hpp:90

Retro::Rw11CntlDEUNA::StartTxRing
void StartTxRing()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1368

Retro::Rw11CntlDEUNA::fRxPollTime
Rtime fRxPollTime
rx poll time interval
Definition: Rw11CntlDEUNA.hpp:381

Retro::Rw11CntlDEUNA::kSTATE_RESET
static const uint16_t kSTATE_RESET
reset
Definition: Rw11CntlDEUNA.hpp:111

Retro::Rw11CntlDEUNA::TxRingIndexNext
uint16_t TxRingIndexNext(uint16_t inc=1) const
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:78

Retro::Rw11CntlDEUNA::kPCMD_HALT
static const uint16_t kPCMD_HALT
HALT: halt.
Definition: Rw11CntlDEUNA.hpp:102

Retro::Rw11CntlDEUNA::kFUNC_RSTAT
static const uint16_t kFUNC_RSTAT
RSTAT: read status.
Definition: Rw11CntlDEUNA.hpp:136

Retro::Rw11CntlDEUNA::kTXR2_M_ONE
static const uint16_t kTXR2_M_ONE
ONE: one collision.
Definition: Rw11CntlDEUNA.hpp:169

Retro::Rw11CntlDEUNA::fRxRingELen
uint16_t fRxRingELen
rx ring entry length
Definition: Rw11CntlDEUNA.hpp:356

Retro::Rw11CntlDEUNA::kMODE_M_DMNT
static const uint16_t kMODE_M_DMNT
DMNT: dis maint message.
Definition: Rw11CntlDEUNA.hpp:157

Retro::Rw11CntlDEUNA::SetRxQueLimit
void SetRxQueLimit(size_t rxqlim)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:462

Retro::Rw11CntlDEUNA::RxPollHandler
int RxPollHandler(const pollfd &pfd)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1686

Retro::Rw11CntlDEUNA::kPR0_M_PDMDWB
static const uint16_t kPR0_M_PDMDWB
PDMDWB: pdmd while busy.
Definition: Rw11CntlDEUNA.hpp:92

Retro::Rw11CntlDEUNA::kMODE_M_DRDC
static const uint16_t kMODE_M_DRDC
DRDC: dis data chaining.
Definition: Rw11CntlDEUNA.hpp:154

Retro::Rw11CntlDEUNA::kPR0_M_TXI
static const uint16_t kPR0_M_TXI
TXI: transmit rung intr.
Definition: Rw11CntlDEUNA.hpp:79

Retro::Rw11CntlDEUNA::MacDefault
std::string MacDefault() const
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:474

Retro::Rw11CntlDEUNA::kPR0_M_PCMD
static const uint16_t kPR0_M_PCMD
PCMD: port command.
Definition: Rw11CntlDEUNA.hpp:88

Retro::Rw11CntlDEUNA::kRXR2_M_OWN
static const uint16_t kRXR2_M_OWN
OWN: owned by DENUA.
Definition: Rw11CntlDEUNA.hpp:182

Retro::Rw11CntlDEUNA::kTXR2_M_OWN
static const uint16_t kTXR2_M_OWN
OWN: owned by DEUNA.
Definition: Rw11CntlDEUNA.hpp:165

Retro::Rw11CntlDEUNA::Reset
void Reset()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:969

Retro::Rw11CntlDEUNA::kSTAT_M_TRNG
static const uint16_t kSTAT_M_TRNG
TRNG: tx ring error.
Definition: Rw11CntlDEUNA.hpp:147

Retro::Rw11CntlDEUNA::fRxDscNxtPC
uint16_t fRxDscNxtPC[4]
rx nxt ring dsc from PrimClist
Definition: Rw11CntlDEUNA.hpp:372

Retro::Rw11CntlDEUNA::kPR0
static const uint16_t kPR0
PR0 reg offset.
Definition: Rw11CntlDEUNA.hpp:67

Retro::Rw11CntlDEUNA::fMcastCnt
int fMcastCnt
mcast count
Definition: Rw11CntlDEUNA.hpp:359

Retro::Rw11CntlDEUNA::kPCMD_STOP
static const uint16_t kPCMD_STOP
STOP: stop.
Definition: Rw11CntlDEUNA.hpp:103

Retro::Rw11CntlDEUNA::kPCMD_SELFTST
static const uint16_t kPCMD_SELFTST
SELFTST: self test.
Definition: Rw11CntlDEUNA.hpp:98

Retro::Rw11CntlDEUNA::LogRingFunc
void LogRingFunc(const char *cmd)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1757

Retro::Rw11CntlDEUNA::kTXR3_M_UBTO
static const uint16_t kTXR3_M_UBTO
UBTO: UNIBUS timeout.
Definition: Rw11CntlDEUNA.hpp:175

Retro::Rw11CntlDEUNA::fStatus
uint16_t fStatus
status
Definition: Rw11CntlDEUNA.hpp:366

Retro::Rw11CntlDEUNA::kDimCtrDelua
static const uint16_t kDimCtrDelua
DELUA count words (MAXCTR)
Definition: Rw11CntlDEUNA.hpp:200

Retro::Rw11CntlDEUNA::UBAddrLen2Wlist
void UBAddrLen2Wlist(uint16_t wlist[2], uint32_t addr, uint16_t len)
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:58

Retro::Rw11CntlDEUNA::fRxPollTimer
RtimerFd fRxPollTimer
rx poll timer
Definition: Rw11CntlDEUNA.hpp:383

Retro::Rw11CntlDEUNA::LogFunc
void LogFunc(const char *cmd, const char *tag1, uint16_t val1, const char *tag2=nullptr, uint16_t val2=0)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1773

Retro::Rw11CntlDEUNA::fMode
uint16_t fMode
mode
Definition: Rw11CntlDEUNA.hpp:365

Retro::Rw11CntlDEUNA::kTXR3_M_TDR
static const uint16_t kTXR3_M_TDR
TDR: TDR value if RTRY=1.
Definition: Rw11CntlDEUNA.hpp:180

Retro::Rw11CntlDEUNA::fPC_rdrxdsccur
size_t fPC_rdrxdsccur
PrimClist: rd rxdsc index.
Definition: Rw11CntlDEUNA.hpp:344

Retro::Rw11CntlDEUNA::kRXR2_M_ENF
static const uint16_t kRXR2_M_ENF
ENF: end of frame.
Definition: Rw11CntlDEUNA.hpp:188

Retro::Rw11CntlDEUNA::kFUNC_WMODE
static const uint16_t kFUNC_WMODE
WMODE: write write.
Definition: Rw11CntlDEUNA.hpp:135

Retro::Rw11CntlDEUNA::kDimCtr
static const uint16_t kDimCtr
max MAXCTR
Definition: Rw11CntlDEUNA.hpp:201

Retro::Rw11CntlDEUNA::fRxQueLimit
size_t fRxQueLimit
rx queue limit
Definition: Rw11CntlDEUNA.hpp:382

Retro::Rw11CntlDEUNA::kFUNC_RMODE
static const uint16_t kFUNC_RMODE
RMODE: read mode.
Definition: Rw11CntlDEUNA.hpp:134

Retro::Rw11CntlDEUNA::kProbeOff
static const uint16_t kProbeOff
probe address offset (pr0)
Definition: Rw11CntlDEUNA.hpp:72

Retro::Rw11CntlDEUNA::fCtrTxFraMcast
uint32_t fCtrTxFraMcast
ctr: xmit mcast frames
Definition: Rw11CntlDEUNA.hpp:395

Retro::Rw11CntlDEUNA::kRXR3_M_BUFL
static const uint16_t kRXR3_M_BUFL
BUFL: buf length error.
Definition: Rw11CntlDEUNA.hpp:190

Retro::Rw11CntlDEUNA::fTxDscCur
uint16_t fTxDscCur[4]
tx cur ring dsc
Definition: Rw11CntlDEUNA.hpp:374

Retro::Rw11CntlDEUNA::kTXR2_M_ERRS
static const uint16_t kTXR2_M_ERRS
ERRS: error summary.
Definition: Rw11CntlDEUNA.hpp:166

Retro::Rw11CntlDEUNA::fPC_rdpr0
size_t fPC_rdpr0
PrimClist: rd pr0 index.
Definition: Rw11CntlDEUNA.hpp:337

Retro::Rw11CntlDEUNA::SetType
void SetType(const std::string &type)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:373

Retro::Rw11CntlDEUNA::kFUNC_RRF
static const uint16_t kFUNC_RRF
RRF: read ring format.
Definition: Rw11CntlDEUNA.hpp:130

Retro::Rw11CntlDEUNA::fRxBufCurr
RethBuf::pbuf_t fRxBufCurr
rx packet current
Definition: Rw11CntlDEUNA.hpp:385

Retro::Rw11CntlDEUNA::fTxRingIndex
uint16_t fTxRingIndex
tx ring index
Definition: Rw11CntlDEUNA.hpp:367

Retro::Rw11CntlDEUNA::kRXR2_M_FRAM
static const uint16_t kRXR2_M_FRAM
FRAM: frame error.
Definition: Rw11CntlDEUNA.hpp:184

Retro::Rw11CntlDEUNA::fCtrFraLoop
uint32_t fCtrFraLoop
ctr: loopback frames
Definition: Rw11CntlDEUNA.hpp:399

Retro::Rw11CntlDEUNA::fPC_rdrxdscnxt
size_t fPC_rdrxdscnxt
PrimClist: rd rxdsc index.
Definition: Rw11CntlDEUNA.hpp:346

Retro::Rw11CntlDEUNA::ClearMacList
void ClearMacList()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:928

Retro::Rw11CntlDEUNA::kPCMD_GETPCBB
static const uint16_t kPCMD_GETPCBB
GETPCBB: get pcb base.
Definition: Rw11CntlDEUNA.hpp:96

Retro::Rw11CntlDEUNA::kPCMD_NOOP
static const uint16_t kPCMD_NOOP
NOOP: noop.
Definition: Rw11CntlDEUNA.hpp:95

Retro::Rw11CntlDEUNA::fRxBufQueue
std::deque< RethBuf::pbuf_t > fRxBufQueue
rx packet queue
Definition: Rw11CntlDEUNA.hpp:384

Retro::Rw11CntlDEUNA::fCtrRxFra
uint32_t fCtrRxFra
ctr: rcvd frames
Definition: Rw11CntlDEUNA.hpp:388

Retro::Rw11CntlDEUNA::fPcbbValid
bool fPcbbValid
pcbb valid
Definition: Rw11CntlDEUNA.hpp:347

Retro::Rw11CntlDEUNA::fPr0Last
uint16_t fPr0Last
last pr0 value
Definition: Rw11CntlDEUNA.hpp:360

Retro::Rw11CntlDEUNA::kPR0_M_INTR
static const uint16_t kPR0_M_INTR
INTR: intr summary.
Definition: Rw11CntlDEUNA.hpp:84

Retro::Rw11CntlDEUNA::kPR1_M_STATE
static const uint16_t kPR1_M_STATE
STATE: port status.
Definition: Rw11CntlDEUNA.hpp:109

Retro::Rw11CntlDEUNA::TxRingDscAddr
uint32_t TxRingDscAddr(uint16_t index) const
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:100

Retro::Rw11CntlDEUNA::kTXR3_M_LCOL
static const uint16_t kTXR3_M_LCOL
LCOL: late collision.
Definition: Rw11CntlDEUNA.hpp:177

Retro::Rw11CntlDEUNA::kMODE_M_TPAD
static const uint16_t kMODE_M_TPAD
TPAD: tx msg padding ena.
Definition: Rw11CntlDEUNA.hpp:155

Retro::Rw11CntlDEUNA::StartRxRing
void StartRxRing()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1410

Retro::Rw11CntlDEUNA::kDimMcast
static const uint16_t kDimMcast
max length Mcast list (MAXMLT)
Definition: Rw11CntlDEUNA.hpp:198

Retro::Rw11CntlDEUNA::Running
bool Running() const
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:33

Retro::Rw11CntlDEUNA::fPcb
uint16_t fPcb[4]
process control block
Definition: Rw11CntlDEUNA.hpp:349

Retro::Rw11CntlDEUNA::MnemoFunc
const char * MnemoFunc(uint16_t func) const
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:495

Retro::Rw11CntlDEUNA::kPR3
static const uint16_t kPR3
PR3 reg offset.
Definition: Rw11CntlDEUNA.hpp:70

Retro::Rw11CntlDEUNA::fRxBufOffset
size_t fRxBufOffset
rx packet offset
Definition: Rw11CntlDEUNA.hpp:386

Retro::Rw11CntlDEUNA::fRxDscCur
uint16_t fRxDscCur[4]
rx cur ring dsc
Definition: Rw11CntlDEUNA.hpp:379

Retro::Rw11CntlDEUNA::kFUNC_RDPA
static const uint16_t kFUNC_RDPA
RDPA: read def MAC.
Definition: Rw11CntlDEUNA.hpp:125

Retro::Rw11CntlDEUNA::kSTATE_SLOAD
static const uint16_t kSTATE_SLOAD
secondary load
Definition: Rw11CntlDEUNA.hpp:119

Retro::Rw11CntlDEUNA::UpdateStat16
void UpdateStat16(uint32_t &stat, size_t ind, uint32_t inc=1)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1715

Retro::Rw11CntlDEUNA::kFUNC_RCTR
static const uint16_t kFUNC_RCTR
RCTR: read counters.
Definition: Rw11CntlDEUNA.hpp:132

Retro::Rw11CntlDEUNA::fTxDscCurPC
uint16_t fTxDscCurPC[4]
tx cur ring dsc from PrimClist
Definition: Rw11CntlDEUNA.hpp:369

Retro::Rw11CntlDEUNA::kMODE_M_DTCR
static const uint16_t kMODE_M_DTCR
DTCR: dis tx CRC.
Definition: Rw11CntlDEUNA.hpp:159

Retro::Rw11CntlDEUNA::kTXR3_M_UFLO
static const uint16_t kTXR3_M_UFLO
UFLO: UNIBUS underflow.
Definition: Rw11CntlDEUNA.hpp:176

Retro::Rw11CntlDEUNA::kMODE_M_ECT
static const uint16_t kMODE_M_ECT
ECT: ena collision test.
Definition: Rw11CntlDEUNA.hpp:156

Retro::Rw11CntlDEUNA::kTXR3_M_BUFL
static const uint16_t kTXR3_M_BUFL
BUFL: buf length error.
Definition: Rw11CntlDEUNA.hpp:174

Retro::Rw11CntlDEUNA::kIbaddr
static const uint16_t kIbaddr
DEUNA default address.
Definition: Rw11CntlDEUNA.hpp:64

Retro::Rw11CntlDEUNA::kProbeInt
static const bool kProbeInt
probe int active
Definition: Rw11CntlDEUNA.hpp:73

Retro::Rw11CntlDEUNA::kRXR2_M_CRC
static const uint16_t kRXR2_M_CRC
CRC: CRC check error.
Definition: Rw11CntlDEUNA.hpp:186

Retro::Rw11CntlDEUNA::kPR1_M_ICAB
static const uint16_t kPR1_M_ICAB
ICAB: cable fail.
Definition: Rw11CntlDEUNA.hpp:106

Retro::Rw11CntlDEUNA::kSTAT_M_RREV
static const uint16_t kSTAT_M_RREV
RREV: ROM version.
Definition: Rw11CntlDEUNA.hpp:150

Retro::Rw11CntlDEUNA::kRXR3_M_NCHN
static const uint16_t kRXR3_M_NCHN
NCHN: no data chaining.
Definition: Rw11CntlDEUNA.hpp:192

Retro::Rw11CntlDEUNA::kPR0_M_BRST
static const uint16_t kPR0_M_BRST
RSET: breset seen.
Definition: Rw11CntlDEUNA.hpp:87

Retro::Rw11CntlDEUNA::kFUNC_RPA
static const uint16_t kFUNC_RPA
RPA: read phys MAC.
Definition: Rw11CntlDEUNA.hpp:126

Retro::Rw11CntlDEUNA::fPcbb
uint32_t fPcbb
process control block base
Definition: Rw11CntlDEUNA.hpp:348

Retro::Rw11CntlDEUNA::kPR0_M_DNI
static const uint16_t kPR0_M_DNI
DNI: done intr.
Definition: Rw11CntlDEUNA.hpp:80

Retro::Rw11CntlDEUNA::kPCMD_START
static const uint16_t kPCMD_START
START: start tx/rx.
Definition: Rw11CntlDEUNA.hpp:99

Retro::Rw11CntlDEUNA::SetRxPollTime
void SetRxPollTime(const Rtime &time)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:450

Retro::Rw11CntlDEUNA::fCtrRxFraLoBuf
uint32_t fCtrRxFraLoBuf
ctr: rcvd frame lost buffers
Definition: Rw11CntlDEUNA.hpp:393

Retro::Rw11CntlDEUNA::RcvCallback
bool RcvCallback(RethBuf::pbuf_t &pbuf)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:525

Retro::Rw11CntlDEUNA::kPC0_M_MBZ
static const uint16_t kPC0_M_MBZ
MBZ.
Definition: Rw11CntlDEUNA.hpp:122

Retro::Rw11CntlDEUNA::SetMacDefault
void SetMacDefault(const std::string &mac)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:400

Retro::Rw11CntlDEUNA::Start
virtual void Start()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:332

Retro::Rw11CntlDEUNA::fTxBuf
RethBuf fTxBuf
tx packet buffer
Definition: Rw11CntlDEUNA.hpp:376

Retro::Rw11CntlDEUNA::fPC_lapcb
size_t fPC_lapcb
PrimClist: la pcb index.
Definition: Rw11CntlDEUNA.hpp:339

Retro::Rw11CntlDEUNA::kFUNC_RCSTAT
static const uint16_t kFUNC_RCSTAT
RCSTAT: read&clr status.
Definition: Rw11CntlDEUNA.hpp:137

Retro::Rw11CntlDEUNA::kPR2
static const uint16_t kPR2
PR2 reg offset.
Definition: Rw11CntlDEUNA.hpp:69

Retro::Rw11CntlDEUNA::MnemoPcmd
const char * MnemoPcmd(uint16_t pcmd) const
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:482

Retro::Rw11CntlDEUNA::kRXR2_M_OFLO
static const uint16_t kRXR2_M_OFLO
OFLO: message overflow.
Definition: Rw11CntlDEUNA.hpp:185

Retro::Rw11CntlDEUNA::fTxDscNxtPC
uint16_t fTxDscNxtPC[4]
tx nxt ring dsc from PrimClist
Definition: Rw11CntlDEUNA.hpp:370

Retro::Rw11CntlDEUNA::kTXR2_M_STF
static const uint16_t kTXR2_M_STF
STF: start of frame.
Definition: Rw11CntlDEUNA.hpp:171

Retro::Rw11CntlDEUNA::kSTAT_M_CERR
static const uint16_t kSTAT_M_CERR
CERR: collision test er.
Definition: Rw11CntlDEUNA.hpp:144

Retro::Rw11CntlDEUNA::kFUNC_WPA
static const uint16_t kFUNC_WPA
WPA: write phys MAC.
Definition: Rw11CntlDEUNA.hpp:127

Retro::Rw11CntlDEUNA::kSTAT_M_BABL
static const uint16_t kSTAT_M_BABL
BABL: xmit on long(DELUA)
Definition: Rw11CntlDEUNA.hpp:143

Retro::Rw11CntlDEUNA::kSTATE_NUHALT
static const uint16_t kSTATE_NUHALT
ni and unibus halted
Definition: Rw11CntlDEUNA.hpp:117

Retro::Rw11CntlDEUNA::fCtrTxByt
uint32_t fCtrTxByt
ctr: xmit bytes
Definition: Rw11CntlDEUNA.hpp:396

Retro::Rw11CntlDEUNA::fCtrTxFra
uint32_t fCtrTxFra
ctr: xmit frames
Definition: Rw11CntlDEUNA.hpp:394

Retro::Rw11CntlDEUNA::kSTATE_UHALT
static const uint16_t kSTATE_UHALT
unibus halted
Definition: Rw11CntlDEUNA.hpp:115

Retro::Rw11CntlDEUNA::kStateTxIdle
@ kStateTxIdle
Definition: Rw11CntlDEUNA.hpp:267

Retro::Rw11CntlDEUNA::kStateTxBusy
@ kStateTxBusy
Definition: Rw11CntlDEUNA.hpp:268

Retro::Rw11CntlDEUNA::fPC_latxdscnxt
size_t fPC_latxdscnxt
PrimClist: la txdsc nxt index.
Definition: Rw11CntlDEUNA.hpp:343

Retro::Rw11CntlDEUNA::kPR0_M_SERI
static const uint16_t kPR0_M_SERI
SERI: status error intr.
Definition: Rw11CntlDEUNA.hpp:76

Retro::Rw11CntlDEUNA::kProbeRem
static const bool kProbeRem
probr rem active
Definition: Rw11CntlDEUNA.hpp:74

Retro::Rw11CntlDEUNA::StopTxRing
void StopTxRing()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1402

Retro::Rw11CntlDEUNA::LogRingInfo
void LogRingInfo(char rxtx, char rw)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1786

Retro::Rw11CntlDEUNA::StopRxRing
void StopRxRing()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1445

Retro::Rw11CntlDEUNA::LogFrameInfo
void LogFrameInfo(char rxtx, const RethBuf &buf)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1803

Retro::Rw11CntlDEUNA::MacFilter
int MacFilter(uint64_t mac)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1704

Retro::Rw11CntlDEUNA::fCtrTimeCleared
Rtime fCtrTimeCleared
ctr: time when cleared
Definition: Rw11CntlDEUNA.hpp:387

Retro::Rw11CntlDEUNA::fRxRingIndex
uint16_t fRxRingIndex
rx ring index
Definition: Rw11CntlDEUNA.hpp:368

Retro::Rw11CntlDEUNA::kTXR2_M_ENF
static const uint16_t kTXR2_M_ENF
ENF: end of frame.
Definition: Rw11CntlDEUNA.hpp:172

Retro::Rw11CntlDEUNA::kFUNC_WRF
static const uint16_t kFUNC_WRF
WRF: write ring format.
Definition: Rw11CntlDEUNA.hpp:131

Retro::Rw11CntlDEUNA::kPR1_M_XPWR
static const uint16_t kPR1_M_XPWR
XPWR: transceive pwr fail.
Definition: Rw11CntlDEUNA.hpp:105

Retro::Rw11CntlDEUNA::Dump
virtual void Dump(std::ostream &os, int ind=0, const char *text=0, int detail=0) const
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:584

Retro::Rw11CntlDEUNA::fPC_larxdsccur
size_t fPC_larxdsccur
PrimClist: la rxdsc index.
Definition: Rw11CntlDEUNA.hpp:345

Retro::Rw11CntlDEUNA::kFUNC_RSID
static const uint16_t kFUNC_RSID
RSID: read system id.
Definition: Rw11CntlDEUNA.hpp:138

Retro::Rw11CntlDEUNA::kTXR3_M_RTRY
static const uint16_t kTXR3_M_RTRY
RTRY: retry failure.
Definition: Rw11CntlDEUNA.hpp:179

Retro::Rw11CntlDEUNA::fTxRingBase
uint32_t fTxRingBase
tx ring base
Definition: Rw11CntlDEUNA.hpp:351

Retro::Rw11CntlDEUNA::fRxRingSize
uint16_t fRxRingSize
rx ring size (# of entries)
Definition: Rw11CntlDEUNA.hpp:355

Retro::Rw11CntlDEUNA::GetPr1
uint16_t GetPr1() const
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1352

Retro::Rw11CntlDEUNA::kSTAT_M_ERRS
static const uint16_t kSTAT_M_ERRS
ERRS: error summary.
Definition: Rw11CntlDEUNA.hpp:141

Retro::Rw11CntlDEUNA::UpdateStat32
void UpdateStat32(uint32_t &stat, size_t ind, uint32_t inc=1)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1725

Retro::Rw11CntlDEUNA::kTXR2_M_DEF
static const uint16_t kTXR2_M_DEF
DEF: deferred.
Definition: Rw11CntlDEUNA.hpp:170

Retro::Rw11CntlDEUNA::TxRingHandler
int TxRingHandler()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1453

Retro::Rw11CntlDEUNA::RxRingDscAddr
uint32_t RxRingDscAddr(uint16_t index) const
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:107

Retro::Rw11CntlDEUNA::kTXR2_M_MORE
static const uint16_t kTXR2_M_MORE
MORE: mult retry needed.
Definition: Rw11CntlDEUNA.hpp:168

Retro::Rw11CntlDEUNA::fMacDefault
uint64_t fMacDefault
default MAC
Definition: Rw11CntlDEUNA.hpp:357

Retro::Rw11CntlDEUNA::fTxRingSize
uint16_t fTxRingSize
tx ring size (# of entries)
Definition: Rw11CntlDEUNA.hpp:352

Retro::Rw11CntlDEUNA::kPR0_M_USCI
static const uint16_t kPR0_M_USCI
USCI: unsol state chang.
Definition: Rw11CntlDEUNA.hpp:83

Retro::Rw11CntlDEUNA::fCtrRxByt
uint32_t fCtrRxByt
ctr: rcvd bytes
Definition: Rw11CntlDEUNA.hpp:390

Retro::Rw11CntlDEUNA::fCtrTxBytMcast
uint32_t fCtrTxBytMcast
ctr: xmit mcast bytes
Definition: Rw11CntlDEUNA.hpp:397

Retro::Rw11CntlDEUNA::fPC_rdtxdscnxt
size_t fPC_rdtxdscnxt
PrimClist: rd txdsc nxt index.
Definition: Rw11CntlDEUNA.hpp:342

Retro::Rw11CntlDEUNA::kPR0_M_INTE
static const uint16_t kPR0_M_INTE
INTE: intr enable.
Definition: Rw11CntlDEUNA.hpp:85

Retro::Rw11CntlDEUNA::kSTATE_PLOAD
static const uint16_t kSTATE_PLOAD
primary load
Definition: Rw11CntlDEUNA.hpp:112

Retro::Rw11CntlDEUNA::kRXR3_M_OVRN
static const uint16_t kRXR3_M_OVRN
OVRN: overrun error.
Definition: Rw11CntlDEUNA.hpp:193

Retro::Rw11CntlDEUNA::kFUNC_WMAL
static const uint16_t kFUNC_WMAL
RMAL: write mcast MAC list.
Definition: Rw11CntlDEUNA.hpp:129

Retro::Rw11CntlDEUNA::kPCMD_BOOT
static const uint16_t kPCMD_BOOT
BOOT: boot.
Definition: Rw11CntlDEUNA.hpp:100

Retro::Rw11CntlDEUNA::kSTAT_M_PTCH
static const uint16_t kSTAT_M_PTCH
PTCH: ROM patch.
Definition: Rw11CntlDEUNA.hpp:148

Retro::Rw11CntlDEUNA::RxRingHandler
int RxRingHandler()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1579

Retro::Rw11CntlDEUNA::kRXR2_M_SEGB
static const uint16_t kRXR2_M_SEGB
SEGB: msg of seg base.
Definition: Rw11CntlDEUNA.hpp:189

Retro::Rw11CntlDEUNA::kTXR2_M_MTCH
static const uint16_t kTXR2_M_MTCH
MTCH: station match.
Definition: Rw11CntlDEUNA.hpp:167

Retro::Rw11CntlDEUNA::Rw11CntlDEUNA
Rw11CntlDEUNA()
Default constructor.
Definition: Rw11CntlDEUNA.cpp:199

Retro::Rw11CntlDEUNA::kStatNPcmdWBOther
@ kStatNPcmdWBOther
Definition: Rw11CntlDEUNA.hpp:217

Retro::Rw11CntlDEUNA::kStatNFuncRpa
@ kStatNFuncRpa
Definition: Rw11CntlDEUNA.hpp:221

Retro::Rw11CntlDEUNA::kStatNFuncWrf
@ kStatNFuncWrf
Definition: Rw11CntlDEUNA.hpp:226

Retro::Rw11CntlDEUNA::kStatNFuncWmode
@ kStatNFuncWmode
Definition: Rw11CntlDEUNA.hpp:230

Retro::Rw11CntlDEUNA::kStatNPcmdGetpcbb
@ kStatNPcmdGetpcbb
Definition: Rw11CntlDEUNA.hpp:207

Retro::Rw11CntlDEUNA::kStatNRxFraPad
@ kStatNRxFraPad
Definition: Rw11CntlDEUNA.hpp:252

Retro::Rw11CntlDEUNA::kStatNRxFraFDst
@ kStatNRxFraFDst
Definition: Rw11CntlDEUNA.hpp:237

Retro::Rw11CntlDEUNA::kStatNTxFraMcast
@ kStatNTxFraMcast
Definition: Rw11CntlDEUNA.hpp:254

Retro::Rw11CntlDEUNA::kStatNRxFraQLDrop
@ kStatNRxFraQLDrop
Definition: Rw11CntlDEUNA.hpp:243

Retro::Rw11CntlDEUNA::kStatNFuncWmal
@ kStatNFuncWmal
Definition: Rw11CntlDEUNA.hpp:224

Retro::Rw11CntlDEUNA::kStatNRxFraFUDrop
@ kStatNRxFraFUDrop
Definition: Rw11CntlDEUNA.hpp:241

Retro::Rw11CntlDEUNA::kStatNFuncRmal
@ kStatNFuncRmal
Definition: Rw11CntlDEUNA.hpp:223

Retro::Rw11CntlDEUNA::kStatNFuncRstat
@ kStatNFuncRstat
Definition: Rw11CntlDEUNA.hpp:231

Retro::Rw11CntlDEUNA::kStatNFraLoop
@ kStatNFraLoop
Definition: Rw11CntlDEUNA.hpp:260

Retro::Rw11CntlDEUNA::kStatNTxByt
@ kStatNTxByt
Definition: Rw11CntlDEUNA.hpp:256

Retro::Rw11CntlDEUNA::kStatNRxBytMcast
@ kStatNRxBytMcast
Definition: Rw11CntlDEUNA.hpp:249

Retro::Rw11CntlDEUNA::kStatNFuncRdpa
@ kStatNFuncRdpa
Definition: Rw11CntlDEUNA.hpp:220

Retro::Rw11CntlDEUNA::kStatNPcmdNoop
@ kStatNPcmdNoop
Definition: Rw11CntlDEUNA.hpp:206

Retro::Rw11CntlDEUNA::kStatNPdmdRestart
@ kStatNPdmdRestart
Definition: Rw11CntlDEUNA.hpp:218

Retro::Rw11CntlDEUNA::kStatNRxFraFMDrop
@ kStatNRxFraFMDrop
Definition: Rw11CntlDEUNA.hpp:242

Retro::Rw11CntlDEUNA::kStatNRxFraSeen
@ kStatNRxFraSeen
Definition: Rw11CntlDEUNA.hpp:236

Retro::Rw11CntlDEUNA::kStatNRxFraMcast
@ kStatNRxFraMcast
Definition: Rw11CntlDEUNA.hpp:246

Retro::Rw11CntlDEUNA::kStatNPcmdGetcmd
@ kStatNPcmdGetcmd
Definition: Rw11CntlDEUNA.hpp:208

Retro::Rw11CntlDEUNA::kStatNFuncUimpl
@ kStatNFuncUimpl
Definition: Rw11CntlDEUNA.hpp:235

Retro::Rw11CntlDEUNA::kStatNFuncRctr
@ kStatNFuncRctr
Definition: Rw11CntlDEUNA.hpp:227

Retro::Rw11CntlDEUNA::kStatNRxFraFBcast
@ kStatNRxFraFBcast
Definition: Rw11CntlDEUNA.hpp:238

Retro::Rw11CntlDEUNA::kStatNPcmdHalt
@ kStatNPcmdHalt
Definition: Rw11CntlDEUNA.hpp:213

Retro::Rw11CntlDEUNA::kStatNTxFraAbort
@ kStatNTxFraAbort
Definition: Rw11CntlDEUNA.hpp:258

Retro::Rw11CntlDEUNA::kStatNFuncRsid
@ kStatNFuncRsid
Definition: Rw11CntlDEUNA.hpp:233

Retro::Rw11CntlDEUNA::kStatNFuncRcctr
@ kStatNFuncRcctr
Definition: Rw11CntlDEUNA.hpp:228

Retro::Rw11CntlDEUNA::kStatNPcmdPdmd
@ kStatNPcmdPdmd
Definition: Rw11CntlDEUNA.hpp:211

Retro::Rw11CntlDEUNA::kStatNFuncRmode
@ kStatNFuncRmode
Definition: Rw11CntlDEUNA.hpp:229

Retro::Rw11CntlDEUNA::kStatNFuncWsid
@ kStatNFuncWsid
Definition: Rw11CntlDEUNA.hpp:234

Retro::Rw11CntlDEUNA::kStatNFuncWpa
@ kStatNFuncWpa
Definition: Rw11CntlDEUNA.hpp:222

Retro::Rw11CntlDEUNA::kStatNRxFraBcast
@ kStatNRxFraBcast
Definition: Rw11CntlDEUNA.hpp:247

Retro::Rw11CntlDEUNA::kStatNRxFraLoBuf
@ kStatNRxFraLoBuf
Definition: Rw11CntlDEUNA.hpp:251

Retro::Rw11CntlDEUNA::kStatNRxFraNRDrop
@ kStatNRxFraNRDrop
Definition: Rw11CntlDEUNA.hpp:244

Retro::Rw11CntlDEUNA::kStatNFuncNoop
@ kStatNFuncNoop
Definition: Rw11CntlDEUNA.hpp:219

Retro::Rw11CntlDEUNA::kStatNRxFraLoInt
@ kStatNRxFraLoInt
Definition: Rw11CntlDEUNA.hpp:250

Retro::Rw11CntlDEUNA::kStatNTxBytMcast
@ kStatNTxBytMcast
Definition: Rw11CntlDEUNA.hpp:257

Retro::Rw11CntlDEUNA::kStatNFuncRrf
@ kStatNFuncRrf
Definition: Rw11CntlDEUNA.hpp:225

Retro::Rw11CntlDEUNA::kStatNFuncRcstat
@ kStatNFuncRcstat
Definition: Rw11CntlDEUNA.hpp:232

Retro::Rw11CntlDEUNA::kStatNPcmdUimpl
@ kStatNPcmdUimpl
Definition: Rw11CntlDEUNA.hpp:215

Retro::Rw11CntlDEUNA::kStatNRxFraFMcast
@ kStatNRxFraFMcast
Definition: Rw11CntlDEUNA.hpp:239

Retro::Rw11CntlDEUNA::kStatNPcmdRsrvd
@ kStatNPcmdRsrvd
Definition: Rw11CntlDEUNA.hpp:214

Retro::Rw11CntlDEUNA::kStatNTxFra
@ kStatNTxFra
Definition: Rw11CntlDEUNA.hpp:253

Retro::Rw11CntlDEUNA::kStatNPcmdStart
@ kStatNPcmdStart
Definition: Rw11CntlDEUNA.hpp:210

Retro::Rw11CntlDEUNA::kStatNPcmdSelftst
@ kStatNPcmdSelftst
Definition: Rw11CntlDEUNA.hpp:209

Retro::Rw11CntlDEUNA::kStatNTxFraBcast
@ kStatNTxFraBcast
Definition: Rw11CntlDEUNA.hpp:255

Retro::Rw11CntlDEUNA::kStatNRxFraFProm
@ kStatNRxFraFProm
Definition: Rw11CntlDEUNA.hpp:240

Retro::Rw11CntlDEUNA::kStatNRxFra
@ kStatNRxFra
Definition: Rw11CntlDEUNA.hpp:245

Retro::Rw11CntlDEUNA::kStatNPcmdStop
@ kStatNPcmdStop
Definition: Rw11CntlDEUNA.hpp:212

Retro::Rw11CntlDEUNA::kStatNRxByt
@ kStatNRxByt
Definition: Rw11CntlDEUNA.hpp:248

Retro::Rw11CntlDEUNA::kStatNTxFraPad
@ kStatNTxFraPad
Definition: Rw11CntlDEUNA.hpp:259

Retro::Rw11CntlDEUNA::kStatNPcmdWBPdmd
@ kStatNPcmdWBPdmd
Definition: Rw11CntlDEUNA.hpp:216

Retro::Rw11CntlDEUNA::kPR0_B_PCMDBP
static const uint16_t kPR0_B_PCMDBP
PCMDBP: pcmd busy prot.
Definition: Rw11CntlDEUNA.hpp:91

Retro::Rw11CntlDEUNA::kSTATE_READY
static const uint16_t kSTATE_READY
ready
Definition: Rw11CntlDEUNA.hpp:113

Retro::Rw11CntlDEUNA::kPR1_M_DELUA
static const uint16_t kPR1_M_DELUA
ID0: 1=DELUA;0=DEUNA
Definition: Rw11CntlDEUNA.hpp:108

Retro::Rw11CntlDEUNA::fRxRingBase
uint32_t fRxRingBase
rx ring base
Definition: Rw11CntlDEUNA.hpp:354

Retro::Rw11CntlDEUNA::LogMacFunc
void LogMacFunc(const char *cmd, uint64_t mac)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1734

Retro::Rw11CntlDEUNA::fCtrRxBytMcast
uint32_t fCtrRxBytMcast
ctr: rcvd mcast bytes
Definition: Rw11CntlDEUNA.hpp:391

Retro::Rw11CntlDEUNA::kMODE_M_PROM
static const uint16_t kMODE_M_PROM
PROM: promiscous mode.
Definition: Rw11CntlDEUNA.hpp:152

Retro::Rw11CntlDEUNA::kPR0_M_PCEI
static const uint16_t kPR0_M_PCEI
PCEI: port cmd err intr.
Definition: Rw11CntlDEUNA.hpp:77

Retro::Rw11CntlDEUNA::kPR0_M_PCWWB
static const uint16_t kPR0_M_PCWWB
PCWWB: pcmd write w busy.
Definition: Rw11CntlDEUNA.hpp:93

Retro::Rw11CntlDEUNA::kStateRxBusy
@ kStateRxBusy
Definition: Rw11CntlDEUNA.hpp:272

Retro::Rw11CntlDEUNA::kStateRxIdle
@ kStateRxIdle
Definition: Rw11CntlDEUNA.hpp:271

Retro::Rw11CntlDEUNA::kStateRxPoll
@ kStateRxPoll
Definition: Rw11CntlDEUNA.hpp:273

Retro::Rw11CntlDEUNA::fTxBufOffset
size_t fTxBufOffset
tx packet offset
Definition: Rw11CntlDEUNA.hpp:377

Retro::Rw11CntlDEUNA::kPR1_M_PCTO
static const uint16_t kPR1_M_PCTO
PCTO: port cmd timeout.
Definition: Rw11CntlDEUNA.hpp:107

Retro::Rw11CntlDEUNA::ClearCtr
void ClearCtr()
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:940

Retro::Rw11CntlDEUNA::fPr1Delua
bool fPr1Delua
pr1 delua flag
Definition: Rw11CntlDEUNA.hpp:362

Retro::Rw11CntlDEUNA::fRingValid
bool fRingValid
ring format valid
Definition: Rw11CntlDEUNA.hpp:350

Retro::Rw11CntlDEUNA::fTxDscNxt
uint16_t fTxDscNxt[4]
tx nxt ring dsc
Definition: Rw11CntlDEUNA.hpp:375

Retro::Rw11CntlDEUNA::fCtrRxFraLoInt
uint32_t fCtrRxFraLoInt
ctr: rcvd frame lost int error
Definition: Rw11CntlDEUNA.hpp:392

Retro::Rw11CntlDEUNA::fPC_latxdsccur
size_t fPC_latxdsccur
PrimClist: la txdsc cur index.
Definition: Rw11CntlDEUNA.hpp:341

Retro::Rw11CntlDEUNA::fRxDscCurPC
uint16_t fRxDscCurPC[4]
rx cur ring dsc from PrimClist
Definition: Rw11CntlDEUNA.hpp:371

Retro::Rw11CntlDEUNA::kMODE_M_MBZ_DELUA
static const uint16_t kMODE_M_MBZ_DELUA
MBZ bit:10,8:7,5:4,1.
Definition: Rw11CntlDEUNA.hpp:163

Retro::Rw11CntlDEUNA::MnemoState
const char * MnemoState(uint16_t state) const
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:512

Retro::Rw11CntlDEUNA::kPR0_M_RCBI
static const uint16_t kPR0_M_RCBI
RCBI: rcv buff unavail.
Definition: Rw11CntlDEUNA.hpp:81

Retro::Rw11CntlDEUNA::fCtrRxFraMcast
uint32_t fCtrRxFraMcast
ctr: rcvd mcast frames
Definition: Rw11CntlDEUNA.hpp:389

Retro::Rw11CntlDEUNA::fPC_rdtxdsccur
size_t fPC_rdtxdsccur
PrimClist: rd txdsc cur index.
Definition: Rw11CntlDEUNA.hpp:340

Retro::Rw11CntlDEUNA::kFUNC_NOOP
static const uint16_t kFUNC_NOOP
NOOP: noop.
Definition: Rw11CntlDEUNA.hpp:124

Retro::Rw11CntlDEUNA::fTxRingState
enum s_tx fTxRingState
tx ring handler state
Definition: Rw11CntlDEUNA.hpp:373

Retro::Rw11CntlDEUNA::kMODE_M_ENAL
static const uint16_t kMODE_M_ENAL
ENAL: ena all mcasts.
Definition: Rw11CntlDEUNA.hpp:153

Retro::Rw11CntlDEUNA::SetRingDsc
static void SetRingDsc(uint16_t dst[4], const uint16_t src[4])
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:114

Retro::Rw11CntlDEUNA::kDimCtrDeuna
static const uint16_t kDimCtrDeuna
DEUNA count words (MAXCTR)
Definition: Rw11CntlDEUNA.hpp:199

Retro::Rw11CntlDEUNA::~Rw11CntlDEUNA
~Rw11CntlDEUNA()
Destructor.
Definition: Rw11CntlDEUNA.cpp:317

Retro::Rw11CntlDEUNA::kPCMD_PDMD
static const uint16_t kPCMD_PDMD
PDMD: poll demand.
Definition: Rw11CntlDEUNA.hpp:101

Retro::Rw11CntlDEUNA::kDimPlt
static const uint16_t kDimPlt
max MAXPLT
Definition: Rw11CntlDEUNA.hpp:202

Retro::Rw11CntlDEUNA::kFUNC_RCCTR
static const uint16_t kFUNC_RCCTR
RCCTR: read&clr counters.
Definition: Rw11CntlDEUNA.hpp:133

Retro::Rw11CntlDEUNA::fPr1State
uint16_t fPr1State
pr1 state
Definition: Rw11CntlDEUNA.hpp:363

Retro::Rw11CntlDEUNA::kMODE_M_HDPX
static const uint16_t kMODE_M_HDPX
HDPX: half-duplex (DEUNA)
Definition: Rw11CntlDEUNA.hpp:161

Retro::Rw11CntlDEUNA::kSTAT_M_RRAM
static const uint16_t kSTAT_M_RRAM
RRAM: run from RAM.
Definition: Rw11CntlDEUNA.hpp:149

Retro::Rw11CntlDEUNA::fMacList
uint64_t fMacList[2+kDimMcast]
MAC list:0=phys,1=bcast,2+=mcast.
Definition: Rw11CntlDEUNA.hpp:358

Retro::Rw11CntlDEUNA::kRXR2_M_STF
static const uint16_t kRXR2_M_STF
STF: start of frame.
Definition: Rw11CntlDEUNA.hpp:187

Retro::Rw11CntlDEUNA::kRXR3_M_UBTO
static const uint16_t kRXR3_M_UBTO
UBTO: UNIBUS timeout.
Definition: Rw11CntlDEUNA.hpp:191

Retro::Rw11CntlDEUNA::kPR1
static const uint16_t kPR1
PR1 reg offset.
Definition: Rw11CntlDEUNA.hpp:68

Retro::Rw11CntlDEUNA::fPr1Pcto
bool fPr1Pcto
pr1 pcto flag
Definition: Rw11CntlDEUNA.hpp:361

Retro::Rw11CntlDEUNA::SetRunning
void SetRunning(bool run)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:997

Retro::Rw11CntlDEUNA::fPC_rdpcb
size_t fPC_rdpcb
PrimClist: rd pcb index.
Definition: Rw11CntlDEUNA.hpp:338

Retro::Rw11CntlDEUNA::kLam
static const int kLam
DEUNA default lam.
Definition: Rw11CntlDEUNA.hpp:65

Retro::Rw11CntlDEUNA::RxRingIndexNext
uint16_t RxRingIndexNext(uint16_t inc=1) const
FIXME_docs.
Definition: Rw11CntlDEUNA.ipp:85

Retro::Rw11CntlDEUNA::kMODE_M_LOOP
static const uint16_t kMODE_M_LOOP
LOOP: int loopback.
Definition: Rw11CntlDEUNA.hpp:160

Retro::Rw11CntlDEUNA::kSTATE_RUN
static const uint16_t kSTATE_RUN
running
Definition: Rw11CntlDEUNA.hpp:114

Retro::Rw11CntlDEUNA::kUBA_M
static const uint32_t kUBA_M
bits of even unibus address
Definition: Rw11CntlDEUNA.hpp:196

Retro::Rw11CntlDEUNA::LogMcastFunc
void LogMcastFunc(const char *cmd)
FIXME_docs.
Definition: Rw11CntlDEUNA.cpp:1744

Retro::Rw11Cntl::fLam
int fLam
attn bit number (-1 of none)
Definition: Rw11Cntl.hpp:110

Retro::Rw11Cntl::fTraceLevel
uint32_t fTraceLevel
trace level; 0=off;1=cntl
Definition: Rw11Cntl.hpp:114

Retro::Rw11Cntl::fType
std::string fType
controller type
Definition: Rw11Cntl.hpp:107

Retro::Rw11Cntl::fPrimClist
RlinkCommandList fPrimClist
clist for attn primary info
Definition: Rw11Cntl.hpp:115

Retro::Rw11Cntl::Connect
RlinkConnect & Connect() const
FIXME_docs.
Definition: Rw11Cntl.ipp:56

Retro::Rw11Cntl::Base
uint16_t Base() const
FIXME_docs.
Definition: Rw11Cntl.ipp:88

Retro::Rw11Cntl::fStats
Rstats fStats
statistics
Definition: Rw11Cntl.hpp:116

Retro::Rw11Cntl::fProbe
Rw11Probe fProbe
controller probe context
Definition: Rw11Cntl.hpp:113

Retro::Rw11Cntl::Cpu
Rw11Cpu & Cpu() const
FIXME_docs.
Definition: Rw11Cntl.ipp:32

Retro::Rw11Cntl::ConfigCntl
void ConfigCntl(const std::string &name, uint16_t base, int lam, uint16_t probeoff, bool probeint, bool proberem)
FIXME_docs.
Definition: Rw11Cntl.cpp:156

Retro::Rw11Cntl::fStarted
bool fStarted
true if Start() called
Definition: Rw11Cntl.hpp:112

Retro::Rw11Cntl::fEnable
bool fEnable
enable flag
Definition: Rw11Cntl.hpp:111

Retro::Rw11Cntl::Server
RlinkServer & Server() const
FIXME_docs.
Definition: Rw11Cntl.ipp:48

Retro::Rw11Cntl::kStatNAttnHdl
@ kStatNAttnHdl
Definition: Rw11Cntl.hpp:93

Retro::Rw11Cntl::Name
const std::string & Name() const
FIXME_docs.
Definition: Rw11Cntl.ipp:80

Retro::Rw11Cntl::LogFile
RlogFile & LogFile() const
FIXME_docs.
Definition: Rw11Cntl.ipp:64

Retro::Rw11Cntl::UnitSetupAll
virtual void UnitSetupAll()
FIXME_docs.
Definition: Rw11Cntl.cpp:113

Retro::Rw11Cntl::fBase
uint16_t fBase
controller base address
Definition: Rw11Cntl.hpp:109

Retro::Rw11Cpu
FIXME_docs.
Definition: Rw11Cpu.hpp:66

Retro::Rw11Cpu::AllIAddrMapInsert
void AllIAddrMapInsert(const std::string &name, uint16_t ibaddr)
FIXME_docs.
Definition: Rw11Cpu.cpp:902

Retro::Rw11Cpu::ModLalh
void ModLalh(RlinkCommandList &clist, size_t ind, uint32_t addr, uint16_t mode=kCPAH_M_22BIT)
FIXME_docs.
Definition: Rw11Cpu.cpp:421

Retro::Rw11Cpu::AddWMem
int AddWMem(RlinkCommandList &clist, uint32_t addr, const uint16_t *buf, size_t size, uint16_t mode=kCPAH_M_22BIT, bool singleblk=false)
FIXME_docs.
Definition: Rw11Cpu.cpp:469

Retro::Rw11Cpu::AddRMem
int AddRMem(RlinkCommandList &clist, uint32_t addr, uint16_t *buf, size_t size, uint16_t mode=kCPAH_M_22BIT, bool singleblk=false)
FIXME_docs.
Definition: Rw11Cpu.cpp:448

Retro::Rw11Cpu::ExecWibr
void ExecWibr(uint16_t ibaddr0, uint16_t data0, uint16_t ibaddr1=0, uint16_t data1=0, uint16_t ibaddr2=0, uint16_t data2=0)
FIXME_docs.
Definition: Rw11Cpu.cpp:491

Retro::Rw11Cpu::AddWibr
int AddWibr(RlinkCommandList &clist, uint16_t ibaddr, uint16_t data)
FIXME_docs.
Definition: Rw11Cpu.cpp:365

Retro::Rw11Cpu::AddRibr
int AddRibr(RlinkCommandList &clist, uint16_t ibaddr)
FIXME_docs.
Definition: Rw11Cpu.cpp:354

Retro::Rw11Cpu::kCPAH_M_UBM22
static const uint16_t kCPAH_M_UBM22
ubmap+22bit
Definition: Rw11Cpu.hpp:228

Retro::Rw11UnitDEUNA
FIXME_docs.
Definition: Rw11UnitDEUNA.hpp:27

Retro::Rw11UnitVirt::Virt
TV & Virt()
FIXME_docs.
Definition: Rw11UnitVirt.ipp:64

Retro::Rw11UnitVirt::HasVirt
bool HasVirt() const
FIXME_docs.
Definition: Rw11UnitVirt.ipp:55

Retro::Rw11VirtEth::Snd
virtual bool Snd(const RethBuf &ebuf, RerrMsg &emsg)=0

Retro::RosPrintf
RosPrintfS< bool > RosPrintf(bool value, const char *form=0, int width=0, int prec=0)
Creates a print object for the formatted output of a bool value.
Definition: RosPrintf.ipp:38

Retro::RethTools::Mac2WList
void Mac2WList(uint64_t mac, uint16_t wlist[3])
FIXME_docs.
Definition: RethTools.ipp:21

Retro::RethTools::WList2Mac
uint64_t WList2Mac(const uint16_t wlist[3])
FIXME_docs.
Definition: RethTools.ipp:32

Retro::RethTools::String2Mac
bool String2Mac(const std::string &str, uint64_t &mac, RerrMsg &emsg)
FIXME_docs.
Definition: RethTools.cpp:52

Retro::RethTools::Mac2String
std::string Mac2String(uint64_t mac)
FIXME_docs.
Definition: RethTools.cpp:34

Retro::Rtools::Bytes2Word
uint16_t Bytes2Word(uint16_t byte0, uint16_t byte1)
FIXME_docs.
Definition: Rtools.ipp:30

Retro
Declaration of class ReventLoop.
Definition: ReventLoop.cpp:47

Retro::RlinkServer::AttnArgs
FIXME_docs.
Definition: RlinkServer.hpp:51

Retro::Rw11Probe::Found
bool Found() const
FIXME_docs.
Definition: Rw11Probe.cpp:52