Subversion Repositories openrisc

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

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