Subversion Repositories openrisc_me

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

// TAP DR-Scan action: implementation

// Copyright (C) 2009  Embecosm Limited <info@embecosm.com>

// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

// This file is part of the Embecosm cycle accurate SystemC JTAG library.

// This program is free software: you can redistribute it and/or modify it

// under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or (at your

// option) any later version.

// This program is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

// License for more details.

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// The C/C++ parts of this program are commented throughout in a fashion

// suitable for processing with Doxygen.

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

// $Id$

#include <iostream>

#include <stdio.h>

#include "TapActionDRScan.h"

#include "TapStateMachine.h"

//! Constructor for "large" DR registers

//! Sets up the superclass with the SystemC completion event and initializes

//! our state as appropriate.

//! This constructor represents large registers as an array of uint64_t, with

//! least significant bits in the lowest numbered element, and any odd bits in

//! the highest numbered element.

//! However if we are presented with an array that represents a "small"

//! (i.e. up to 64-bit) register, we will store it efficiently.

//! @param[in] doneEvent     SystemC event to be signalled when this action is

//!                          complete.

//! @param[in] _dRegInArray  The register to shift in.

//! @param[in] _dRegSize     Size in bits of the register to shift in.

TapActionDRScan::TapActionDRScan (sc_core::sc_event *_doneEvent,

                                  uint64_t          *_dRegInArray,

                                  int                _dRegSize

                                  ) :

  TapAction (_doneEvent),

  dRegBitSize (_dRegSize),

  dRegWordSize ((_dRegSize + 63) / 64),

  goToPauseState(0),

  bitsBeforePause(0),

  bitsShifted (0),

  dRScanState (SHIFT_DR_PREPARING)

{

  // Small registers are represented simply. Large registers are copied to a

  // local instance (since we destroy dRegIn when shifting it)

  if (1 == dRegWordSize)

    {

      dRegIn  = _dRegInArray[0];

      dRegOut = 0;

    }

  else

    {

      dRegInArray  = new uint64_t [dRegWordSize];

      dRegOutArray = new uint64_t [dRegWordSize];

      // Copy in the in array and zero the out array

      for (int i = 0; i < dRegWordSize; i++)

        {

          dRegInArray[i]  = _dRegInArray[i];

          dRegOutArray[i] = 0;

        }

      // Create a mask for the top word

      int maskBits = ((dRegBitSize - 1) % 64) + 1;

      topMask = (1ULL << maskBits) - 1ULL;

    }

}       // TapActionDRScan ()

//! Constructor for small DR registers

//! Sets up the superclass with the SystemC completion event and initializes

//! our state as appropriate.

//! This constructor represents small registers in a single uint64_t

//! @param[in] doneEvent  SystemC event to be signalled when this action is

//!                       complete.

//! @param[in] _dRegIn    The register to shift in.

//! @param[in] _dRegSize  Size in bits of the register to shift in. Must be no

//!                       greater than 64, or we give a rude message and set

//!                       the value to 64 anyway.

TapActionDRScan::TapActionDRScan (sc_core::sc_event *_doneEvent,

                                  uint64_t           _dRegIn,

                                  int                _dRegSize) :

  TapAction (_doneEvent),

  dRegBitSize (_dRegSize),

  dRegWordSize (1),

  goToPauseState(0),

  bitsBeforePause(0),

  bitsShifted (0),

  dRScanState (SHIFT_DR_PREPARING)

{

  // Print a rude message if we are not small

  if (dRegBitSize > 64)

    {

      std::cerr << "Simple DR size reduced to 64 bits" << std::endl;

      dRegBitSize = 64;

    }

  // Simple representation

  dRegIn  = _dRegIn;

  dRegOut = 0;

}       // TapActionDRScan ()

//! Constructor for "large" DR registers using special PAUSE state

//! Sets up the superclass with the SystemC completion event and initializes

//! our state as appropriate.

//! This constructor represents large registers as an array of uint64_t, with

//! least significant bits in the lowest numbered element, and any odd bits in

//! the highest numbered element.

//! However if we are presented with an array that represents a "small"

//! (i.e. up to 64-bit) register, we will store it efficiently.

//! @param[in] doneEvent     SystemC event to be signalled when this action is

//!                          complete.

//! @param[in] _dRegInArray  The register to shift in.

//! @param[in] _dRegSize     Size in bits of the register to shift in.

//! @param[in] _goToPauseState     Switch determining if we go to PAUSE state after _bitsBeforePauseState and poll for TDO=0

//! @param[in] _bitsBeforePauseState     Number of bits to shift in before going to shift pause state and polling TDO, indicating transaction has completed

TapActionDRScan::TapActionDRScan (sc_core::sc_event *_doneEvent,

                                  uint64_t          *_dRegInArray,

                                  int                _dRegSize,

                                  int                _goToPauseState,

                                  int                _bitsBeforePauseState

                                  ) :

  TapAction (_doneEvent),

  dRegBitSize (_dRegSize),

  dRegWordSize ((_dRegSize + 63) / 64),

  goToPauseState(_goToPauseState),

  bitsBeforePause(_bitsBeforePauseState),

  pauseStateCount(0),

  bitsShifted (0),

  dRScanState (SHIFT_DR_PREPARING)

{

  // Small registers are represented simply. Large registers are copied to a

  // local instance (since we destroy dRegIn when shifting it)

  if (1 == dRegWordSize)

    {

      dRegIn  = _dRegInArray[0];

      dRegOut = 0;

    }

  else

    {

      dRegInArray  = new uint64_t [dRegWordSize];

      dRegOutArray = new uint64_t [dRegWordSize];

      // Copy in the in array and zero the out array

      for (int i = 0; i < dRegWordSize; i++)

        {

          dRegInArray[i]  = _dRegInArray[i];

          dRegOutArray[i] = 0;

        }

      // Create a mask for the top word

      int maskBits = ((dRegBitSize - 1) % 64) + 1;

      topMask = (1ULL << maskBits) - 1ULL;

    }

}       // TapActionDRScan ()

//! Constructor for small DR registers using special PAUSE state

//! Sets up the superclass with the SystemC completion event and initializes

//! our state as appropriate.

//! This constructor represents small registers in a single uint64_t

//! @param[in] doneEvent  SystemC event to be signalled when this action is

//!                       complete.

//! @param[in] _dRegIn    The register to shift in.

//! @param[in] _dRegSize  Size in bits of the register to shift in. Must be no

//!                       greater than 64, or we give a rude message and set

//!                       the value to 64 anyway.

//! @param[in] _goToPauseState     Switch determining if we go to PAUSE state after _bitsBeforePauseState and poll for TDO=0

//! @param[in] _bitsBeforePauseState     Number of bits to shift in before going to shift pause state and polling TDO, indicating transaction has completed

TapActionDRScan::TapActionDRScan (sc_core::sc_event *_doneEvent,

                                  uint64_t           _dRegIn,

                                  int                _dRegSize,

                                  int                _goToPauseState,

                                  int                _bitsBeforePauseState

                                  ) :

  TapAction (_doneEvent),

  dRegBitSize (_dRegSize),

  dRegWordSize (1),

  goToPauseState(_goToPauseState),

  bitsBeforePause(_bitsBeforePauseState),

  pauseStateCount(0),

  bitsShifted (0),

  dRScanState (SHIFT_DR_PREPARING)

{

  // Print a rude message if we are not small

  if (dRegBitSize > 64)

    {

      std::cerr << "Simple DR size reduced to 64 bits" << std::endl;

      dRegBitSize = 64;

    }

  // Simple representation

  dRegIn  = _dRegIn;

  dRegOut = 0;

}       // TapActionDRScan ()

//! Destructor.

//! If we allocated them, free the large registers

TapActionDRScan::~TapActionDRScan ()

{

  if (dRegWordSize > 1)

    {

      delete [] dRegInArray;

      delete [] dRegOutArray;

    }

}       // ~TapActionDRScan ()

//! Process the Shift-DR action

//! This drives the DR-Scan state. We can only do this if we have the TAP

//! state machine in a consistent state, which in turn is only possible if we

//! have been through a reset cycle.

//! If the state machine shows it has yet to be through a reset cycle, we

//! drive that cycle, after issuing a warning. This functionality is provided

//! by the parent class, TapAction::.

//! @param[in]  tapStateMachine  The TAP state machine with which this action

//!                              is associated. 

//! @param[out] tdi              The value to drive on TDI

//! @param[in]  tdo              The value currently on TDO

//! @param[out] tms              The value to drive on TMS

//! @return  True if the action is complete

bool

TapActionDRScan::process (TapStateMachine *tapStateMachine,

                          bool            &tdi,

                          bool             tdo,

                          bool            &tms)

{

  // Ensure we are in a consistent state. If not then we'll have moved towards

  // it and can return with the given tms

  if (!checkResetDone (tapStateMachine, tms, true))

    {

      return false;

    }

  if (goToPauseState)

    {

      switch (dRScanState)

        {

        case SHIFT_DR_PREPARING:

          // Are we in the Shift-DR state yet?

          if (!tapStateMachine->targetState (TAP_SHIFT_DR, tms))

            {

              return  false;            // Not there. Accept the TMS value

            }

          else

            {

              dRScanState = SHIFT_DR_SHIFTING_BEFORE_PAUSE;     // Drop through

            }

        case SHIFT_DR_SHIFTING_BEFORE_PAUSE:

          // Are we still shifting stuff?

          if (bitsShifted < bitsBeforePause)

            {

              // We are in the Shift-DR state. Another bit about to be done, so

              // increment the count

              bitsShifted++;

              // Set the TDI value. In a routine to keep this tidy.

              tdi = shiftDRegOut ();

              // Record the TDO value. This is always a cycle late, so we ignore

              // it the first time. The value shifts in from the top.

              if (bitsShifted > 1)

                {

                  shiftDRegIn (tdo);

                }

              // TMS is 0 to keep us here UNLESS this is the last bit, in which case

              // it is 1 to move us into Exit1-DR.

              tms = (bitsShifted == bitsBeforePause);

              // Not done until we've updated

              return false;

            }

          else

            {

              // Capture the last TDO bit

              shiftDRegIn (tdo);

              // Now lower TMS to go to PAUSE_DR

              tms = false;

              dRScanState = SHIFT_DR_SHIFTING_PAUSE;

            }

        case SHIFT_DR_SHIFTING_PAUSE:

          {

            if (!tapStateMachine->targetState (TAP_PAUSE_DR, tms))

              {

                return  false;          // Not there. Accept the TMS value

              }

            if ( pauseStateCount++ < 3)

              return false;

            // Sit in DR_PAUSE state and cycle until TDO is low

            // tms starts false, should get set to true on the cycle

            // tdo goes low, then the next cycle we go back to SHIFT_DR

            // and we return so tms isn't set again.

            if (!tdo)

              {

                tms = true;

                dRScanState = SHIFT_DR_EXIT2;

                return false;

              }

          }

        case SHIFT_DR_EXIT2:

          {

            tms = false;

            shiftDRegIn (0);

            dRScanState = SHIFT_DR_SHIFTING_AFTER_PAUSE;

            return false;

          }

        case SHIFT_DR_SHIFTING_AFTER_PAUSE:

          {

            if (bitsShifted < dRegBitSize)

              {

                // We are in the Shift-DR state. Another bit about to be done, so

                // increment the count

                bitsShifted++;

                // Set the TDI value. In a routine to keep this tidy.

                tdi = shiftDRegOut ();

                //printf("shifting after pause (%d+32=%d) %d of %d tdo=%d\n",bitsBeforePause,bitsBeforePause+32, bitsShifted, dRegBitSize,(tdo) ? 1 : 0);

                shiftDRegIn (tdo);

                // TMS is 0 to keep us here UNLESS this is the last bit, in which case

                // it is 1 to move us into Exit1-DR.

                tms = (bitsShifted == dRegBitSize);

                // Not done until we've updated

                return false;

              }

            else

              {

                // Capture the last TDO bit

                shiftDRegIn (tdo);

                dRScanState = SHIFT_DR_UPDATING;        // Drop through

              }

          }

        case SHIFT_DR_UPDATING:

          // Are we still trying to update?

          if (!tapStateMachine->targetState (TAP_UPDATE_DR, tms))

            {

              return  false;            // Not there. Accept the TMS value

            }

          else

            {

              return  true;                     // All done

            }

        }

    }

  else

    {

      switch (dRScanState)

        {

        case SHIFT_DR_PREPARING:

          // Are we in the Shift-DR state yet?

          if (!tapStateMachine->targetState (TAP_SHIFT_DR, tms))

            {

              return  false;            // Not there. Accept the TMS value

            }

          else

            {

              dRScanState = SHIFT_DR_SHIFTING;  // Drop through

            }

        case SHIFT_DR_SHIFTING:

          // Are we still shifting stuff?

          if (bitsShifted < dRegBitSize)

            {

              // We are in the Shift-DR state. Another bit about to be done, so

              // increment the count

              bitsShifted++;

              // Set the TDI value. In a routine to keep this tidy.

              tdi = shiftDRegOut ();

              // Record the TDO value. This is always a cycle late, so we ignore

              // it the first time. The value shifts in from the top.

              if (bitsShifted > 1)

                {

                  shiftDRegIn (tdo);

                }

              // TMS is 0 to keep us here UNLESS this is the last bit, in which case

              // it is 1 to move us into Exit1-DR.

              tms = (bitsShifted == dRegBitSize);

              // Not done until we've updated

              return false;

            }

          else

            {

              // Capture the last TDO bit

              shiftDRegIn (tdo);

              dRScanState = SHIFT_DR_UPDATING;  // Drop through

            }

        case SHIFT_DR_UPDATING:

          // Are we still trying to update?

          if (!tapStateMachine->targetState (TAP_UPDATE_DR, tms))

            {

              return  false;            // Not there. Accept the TMS value

            }

          else

            {

              return  true;                     // All done

            }

        }

    }

}       // process ()

//! Get the shifted out value.

//! This version works with large values.

//! @param[out] dRegArray  Array for the result

void

TapActionDRScan::getDRegOut (uint64_t  dRegArray[])

{

  if (1 == dRegWordSize)

    {

      dRegArray[0] = dRegOut;

    }

  else

    {

      for (int i = 0 ; i < dRegWordSize; i++)

        {

          dRegArray[i] = dRegOutArray[i];

        }

    }

}       // getDRegOut ()

//! Get the shifted out value.

//! This version is for small values. For large values it silently returns the

//! bottom 64 bits only.

//! @todo  Should we give an error. Or is it useful to allow efficient access

//!        to the bottom 64 bits?

//! @return  The value shifted out (or the bottom 64 bits thereof if the

//!          register is "large").

uint64_t

TapActionDRScan::getDRegOut ()

{

  if (1 == dRegWordSize)

    {

      return dRegOut;

    }

  else

    {

      return dRegOutArray[0];

    }

}       // getDRegOut ()

//! Utility to shift the bottom bit out of the dReg.

//! Two flavours depending on whether we have a "small" register

//! @return  The bit shifted out.

bool

TapActionDRScan::shiftDRegOut ()

{

  if (1 == dRegWordSize)                // "Small" register

    {

      bool  res = dRegIn & 1;

      dRegIn >>= 1;

      return  res;

    }

  else                                  // "Large" register

    {

      bool  res = (dRegInArray[0] & 1) == 1;

      // Shift all but the first word along

      for (int  i = 0; i < (dRegWordSize - 1); i++)

        {

          dRegInArray[i] = (dRegInArray[i] >> 1) | (dRegInArray[i+1] << 63);

        }

      // Shift the first word

      dRegInArray[dRegWordSize - 1] >>= 1;

      return  res;

    }

}       // shiftDRegOut ()

//! Utility to shift the top bit into the dReg.

//! Two flavours depending on whether we have a "small" register

//! @param bitIn  The bit to shift in the top

void

TapActionDRScan::shiftDRegIn (bool  bitIn)

{

  if (1 == dRegWordSize)                // "Small" register

    {

      dRegOut >>= 1;                    // Move all the existing bits right

      if (bitIn)                        // OR any new bit in

        {

          uint64_t tmpBit = 1ULL << (dRegBitSize - 1);

          dRegOut |= tmpBit;

        }

    }

  else                                  // "Large" register

    {

      // Shift all but the first word along

      for (int  i = 0; i < (dRegWordSize - 1); i++)

        {

          dRegOutArray[i] >>= 1;

          dRegOutArray[i]  |= dRegOutArray[i+1] << 63;

        }

      // The first word is shifted and the new bit masked in

      dRegOutArray[dRegWordSize - 1] >>= 1;

      dRegOutArray[dRegWordSize - 1]  |= bitIn ? (topMask + 1) >> 1 : 0;

    }

}       // shiftDRegIn ()