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