Subversion Repositories openrisc

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

// TAP IR-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 "TapActionIRScan.h"

#include "TapStateMachine.h"

//! Constructor

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

//! our state as appropriate.

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

//!                       complete.

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

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

TapActionIRScan::TapActionIRScan (sc_core::sc_event *_doneEvent,

                                  uint32_t           _iRegIn,

                                  int                _iRegSize) :

  TapAction (_doneEvent),

  iRegIn (_iRegIn),

  iRegSize (_iRegSize),

  iRegOut (0),

  bitsShifted (0),

  iRScanState (SHIFT_IR_PREPARING)

{

}       // TapActionIRScan ()

//! Process the Shift-IR action

//! This drives the IR-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

TapActionIRScan::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;

    }

  // We are consistent, so work through the IR-Scan process

  switch (iRScanState)

    {

    case SHIFT_IR_PREPARING:

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

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

        {

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

        }

      else

        {

          iRScanState = SHIFT_IR_SHIFTING;      // Drop through

        }

    case SHIFT_IR_SHIFTING:

      // Are we still shifting stuff?

      if (bitsShifted < iRegSize)

        {

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

          // increment the count

          bitsShifted++;

          // Shift out the TDI value from the bottom of the register

          tdi       = iRegIn & 1;

          iRegIn >>= 1;

          // 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)

            {

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

              if (tdo)                  // OR any new bit in

                {

                  uint32_t tmpBit = 1 << (iRegSize - 1);

                  iRegOut |= tmpBit;

                }

            }

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

          // case it is 1 to move us into Exit1-IR.

          tms = (bitsShifted == iRegSize);

          return false;

        }

      else

        {

          // Capture the last TDO bit

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

          if (tdo)                      // OR any new bit in

            {

              uint32_t tmpBit = 1 << (iRegSize - 1);

              iRegOut |= tmpBit;

            }

          iRScanState = SHIFT_IR_UPDATING;      // Drop through

        }

    case SHIFT_IR_UPDATING:

      // Are we still trying to update?

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

        {

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

        }

      else

        {

          return  true;                 // All done

        }

    }

}       // process ()

//! Get the shifted out register

//! @return  The value of the shifted our register

uint32_t

TapActionIRScan::getIRegOut ()

{

  return  iRegOut;

}       // getIRegOut ()