torc::bitstream::Virtex7 Class Reference

Virtex7 bitstream. More...

#include <Virtex7.hpp>

Inheritance diagram for torc::bitstream::Virtex7:

Collaboration diagram for torc::bitstream::Virtex7:

Data Structures
class	FrameAddress
struct	FrameRowDesignator
	Frame row designator: top/bottom flag and row index. More...

Public Types
enum	ERegister {   eRegisterCRC = 0, eRegisterFAR, eRegisterFDRI, eRegisterFDRO,   eRegisterCMD, eRegisterCTL0, eRegisterMASK, eRegisterSTAT,   eRegisterLOUT, eRegisterCOR0, eRegisterMFWR, eRegisterCBC,   eRegisterIDCODE, eRegisterAXSS, eRegisterCOR1, eRegisterWBSTAR = 16,   eRegisterTIMER, eRegisterBOOTSTS = 22, eRegisterCTL1 = 24, eRegisterCount }
	Configuration register enumeration. More...
enum	ECommand {   eCommandNULL = 0, eCommandWCFG, eCommandMFW, eCommandDGHIGH,   eCommandLFRM = eCommandDGHIGH, eCommandRCFG, eCommandSTART, eCommandRCAP,   eCommandRCRC, eCommandAGHIGH, eCommandSWITCH, eCommandGRESTORE,   eCommandSHUTDOWN, eCommandGCAPTURE, eCommandDESYNCH, eCommandReserved,   eCommandIPROG, eCommandCRCC, eCommandLTIMER, eCommandCount }
	Configuration register enumeration. More...
enum	EFar {   eFarMaskBlockType = 0x03800000, eFarShiftBlockType = 23, eFarMaskTopBottom = 0x00400000, eFarShiftTopBottom = 22,   eFarMaskRow = 0x003e0000, eFarShiftRow = 17, eFarMaskMajor = 0x0001ff80, eFarShiftMajor = 7,   eFarMaskMinor = 0x0000007f, eFarShiftMinor = 0 }
	Frame Address Register subfields. More...
enum	EFarTopBottom { eFarTop = 0, eFarBottom = 1 }
	Frame Address Register top and bottom constants. More...
enum	EFarBlockType {   eFarBlockType0 = 0, eFarBlockType1, eFarBlockType2, eFarBlockType3,   eFarBlockType4, eFarBlockType5, eFarBlockType6, eFarBlockType7,   eFarBlockTypeCount }
	Frame Address Register block type constants. More...
enum	{ eStartAddr = 0x1fffffff, eTimerValue = 0x3fffffff }
	Assorted Constants. More...
enum	EColumnType {   eColumnTypeEmpty = 0, eColumnTypeInt, eColumnTypeBram, eColumnTypeCfg,   eColumnTypeClb, eColumnTypeClock, eColumnTypeCmt, eColumnTypeDsp,   eColumnTypeGtx, eColumnTypeIoi, eColumnTypeVframe, eColumnTypePss,   eColumnTypeCount }
	Major Column Types. More...
enum	{ eFrameLength = 101 }
	Frame length. More...
enum	{ eRowPadFrames = 2 }
	Number of pad frames after each frame row. More...
enum	{ eClockRegionRows = 52 }
	Number of rows in a clock region. More...
enum	{ eBlockTypeCount = 8 }
	The block type count is fixed at eight across all Xilinx architectures. More...
enum	EBitstreamType { eBitstreamTypeFull, eBitstreamTypePartialActive, eBitstreamTypePartialShutdown }
	The bitstream type to generate. Use eBitstreamFull to fully reconfigure a device, eBitstreamTypePartialActive to partially reconfigure it while it continues to run, or eBitstreamTypePartialShutdown to partially recongifure it after shutting it down. More...
enum	EFrameInclude { eFrameIncludeOnlyDirtyFrames, eFrameIncludeAllUsedFrames }
	The frames to include in a partial bitstream. Use eFrameIncludeOnlyDirtyFrames to include only dirty frames, or eFrameStateAllUsedFrames to include all allocated frames, dirty or not. Note that if not all frames were allocated, eFrameStateAllUsedFrames is not the same as a full bitstream. More...
typedef std::string	string
	Imported type name. More...
typedef boost::uint8_t	uint8_t
	Imported type name. More...
typedef boost::uint16_t	uint16_t
	Imported type name. More...
typedef torc::common::EDevice	EDevice
	Imported type name. More...
typedef std::map< std::string, uint32_t >	TileTypeNameToColumnType
	Mapping from tile type names to column types. More...
typedef std::map< uint16_t, uint32_t >	TileTypeIndexToColumnType
	Mapping from tile indexes to column types. More...
enum	EPacketType { ePacketType1 = 1, ePacketType2, ePacketTypeCount = 8 }
	Packet type enumeration. More...
enum	EOpcode {   eOpcodeNOP = 0, eOpcodeRead, eOpcodeWrite, eOpcodeReserved,   eOpcodeCount }
	Packet opcode enumeration. More...
enum	EPacket {   ePacketMaskType = 0xe0000000, ePacketShiftType = 29, ePacketMaskOpcode = 0x18000000, ePacketShiftOpcode = 27,   ePacketMaskType1Address = 0x07ffe000, ePacketShiftType1Address = 13, ePacketMaskType1Reserved = 0x00001800, ePacketShiftType1Reserved = 11,   ePacketMaskType1Count = 0x000007ff, ePacketShiftType1Count = 0, ePacketMaskType2Count = 0x07ffffff, ePacketShiftType2Count = 0 }
	Packet subfields. More...
enum	ESynchronization { eSynchronizationDummy = 0xffffffff, eSynchronizationSync = 0xaa995566, eSynchronizationBusWidthSync = 0x000000bb, eSynchronizationBusWidthDetect = 0x11220044 }
	Synchronization words. More...
typedef VirtexFrame	frame_t
	FrameSet frame type. More...
typedef VirtexFrame::word_t	word_t
	FrameSet word type. More...

Public Member Functions
	Virtex7 (void)
	Basic Constructor. More...
virtual void	initializeDeviceInfo (const std::string &inDeviceName)
	Initialize the Device Information. More...
virtual void	initializeFrameMaps (void)
	Initialize the maps between frame indexes and frame addresses. This is generally useful only for internal purposes. More...
virtual void	readFramePackets (void)
	Read frame data into the frame blocks structure. More...
virtual VirtexPacketVector::iterator	deleteFramePackets (void)
	Discard the existing frame packets and return an iterator to the start position. More...
virtual VirtexPacketVector	generateFullBitstreamPackets (void)
	Return a packet vector with full frame data. More...
virtual VirtexPacketVector	generateFullBitstreamPrefix (void)
	Return a packet vector with the full bitstream prefix. More...
virtual VirtexPacketVector	generateFullBitstreamSuffix (void)
	Return a packet vector with the full bitstream suffix. More...
virtual VirtexPacketVector	generatePartialBitstreamPackets (EFrameInclude inFrameInclusion)
	Return a packet vector with partial frame data. More...
virtual VirtexPacketVector	generatePartialBitstreamPrefix (EBitstreamType inBitstreamType)
	Return a packet vector with the partial bitstream prefix. More...
virtual VirtexPacketVector	generatePartialBitstreamSuffix (EBitstreamType inBitstreamType)
	Return a packet vector with the partial bitstream suffix. More...
VirtexFrameBlocks	getBitstreamFrames (EFarTopBottom inTopBottom, uint32_t inFrameRow, uint32_t inBitCol, uint32_t inBlockCount=eBlockTypeCount)
	Returns frames for specified bitstream tile column. inTopBottom The top or bottom half of the device: eFarTop or eFarBottom. inFrameRow The frame or clock region row in the area specified by inTopBottom. inBitCol The bitstream column coordinate (different than the XDL column coordinate). inBlockCount The highest block type requested (8 for Xilinx architectures). More...
VirtexFrameBlocks	getBitstreamFrames (uint32_t inBitRow, uint32_t inBitCol, uint32_t &outBeginBit, uint32_t &outEndBit, uint32_t inBlockCount=eBlockTypeCount)
	Returns frames for specified bitstream tile column. inBitRow The bitstream row coordinate (same as the XDL row coordinate). inBitCol The bitstream column coordinate (different than the XDL column coordinate). outBeginBit The bit index of the beginning of the requested tile. outEndBit The bit index of the end of the requested tile. inBlockCount The highest block type requested (8 for Xilinx architectures). More...
VirtexFrameBlocks	getXdlFrames (uint32_t inXdlRow, uint32_t inXdlCol, uint32_t &outBeginBit, uint32_t &outEndBit, uint32_t inBlockCount=eBlockTypeCount)
	Returns frames for specified XDL tile coordinates. inXldRow The XDL row coordinate. inXdlCol The XDL column coordinate. outBeginBit The bit index of the beginning of the requested tile. outEndBit The bit index of the end of the requested tile. inBlockCount The highest block type requested (8 for Xilinx architectures). More...
uint32_t	getPrimaryXdlColumn (uint32_t inXdlRow, uint32_t inXdlCol)
	Returns the primary column corresponding to the given tile. If the specified tile falls in an INT_L or INT_R tile, this function returns the index of the corresponding primary XDL column. inXdlCol The XDL column coordinate. More...
virtual void	splitFrameIndex (uint32_t inFrameIndex, uint32_t &outMajorIndex, uint32_t &outMinorIndex)
	Split the given frame index into the base index of the major frame and the index of the minor frame. More...
DEPRECATED void	initializeFullFrameBlocks (void)
	Loads full bitstream frames into block data structure. More...
DEPRECATED void	updateFullFrameBlocks (void)
	Transfers frame block data into the full bitstream frame packet. More...
virtual uint32_t	getFrameRowCount (void) const
	Return the number of frame rows for the current device. More...
virtual uint32_t	getFrameLength (void) const
	Return the frame length for the current device. More...
virtual uint32_t	getRowPadFrames (void) const
	Return the number of pad frames after each row. More...
virtual void	readPackets (std::istream &inStream)
	Read bitstream packets from a stream. More...
virtual void	writePackets (std::ostream &inStream)
	Write bitstream packets to a stream. More...
virtual void	updateFramePackets (EBitstreamType inBitstreamType=eBitstreamTypeFull, EFrameInclude inFrameInclusion=eFrameIncludeAllUsedFrames)
	Update the bitstream frame packets By default this updates the bitstream with full frame data. More...
virtual void	generateBitstream (EBitstreamType inBitstreamType=eBitstreamTypeFull, EFrameInclude inFrameInclusion=eFrameIncludeAllUsedFrames)
	Discard existing packets and generate bitstream packets from frame data. By default this generates packets for a full bitstream. More...
virtual void	preflightPackets (void)
	Preflight the packets. More...
virtual void	updatePacketLength (void)
	Update the header packet length. More...
iterator	insert (iterator position, const value_type &val)
	Regular std::vector inserter. More...
void	insert (iterator position, size_type n, const value_type &val)
	Regular std::vector inserter. More...
template<class InputIterator >
void	insert (iterator position, InputIterator first, InputIterator last)
	Regular std::vector inserter. More...
void	insert (VirtexPacketVector::iterator inPosition, const VirtexPacketVector &inVector)
	Insert the contents of a packet vector at the specified position. More...
void	append (const VirtexPacketVector &inVector)
	Append the contents of a packet vector to the end of the bitstream. More...
VirtexFrameBlocks &	getFrameBlocks (void)
	Return the configuration frame blocks. More...
void	write (std::ostream &inStream, uint8_t inVal)
	Write a uint8_t to the stream. More...
void	write (std::ostream &inStream, uint16_t inVal)
	Write a uint16_t to the stream. More...
void	write (std::ostream &inStream, uint32_t inVal)
	Write a uint32_t to the stream. More...
virtual void	write (std::ostream &inStream)
	Write the bitstream header and packets to a stream. More...
void	writeHeaderString (std::ostream &inStream, const string &inString)
	Write a Xilinx-style header string to the stream. More...
virtual void	readHeader (std::istream &inStream)
	Read the bitstream header. More...
void	cleanDateAndTime (void)
	Clean up the header date and time by replacing embedded spaces with zeros. More...
virtual void	writeDeviceInfo (std::ostream &inStream, const std::string &inDeviceName)
	Output static device information to a stream. More...
void	setDeviceInfo (const DeviceInfo &rhs)
	Assign static device information for the current bitstream. More...
void	setDevice (const std::string &inDeviceName)
	Assign the device enumeration constant for the given device name. More...
virtual void	read (std::istream &inStream, bool inCleanDateAndTime=true)
	Read the bitstream header and packets from a stream. More...
virtual void	writeHeader (std::ostream &inStream)
	Write the bitstream header to the stream. More...
void	setDesignName (const string &inDesignName)
	Set the design name. More...
void	setDeviceName (const string &inDeviceName)
	Set the device name. More...
void	setDesignDate (const string &inDesignDate)
	Set the design date. More...
void	setDesignTime (const string &inDesignTime)
	Set the design time. More...
const string &	getDesignName (void) const
	Return the design name. More...
const string &	getDeviceName (void) const
	Return the device name. More...
const string &	getDesignDate (void) const
	Return the design date. More...
const string &	getDesignTime (void) const
	Return the design time. More...
uint32_t	getBitstreamByteLength (void) const
	Return the bitstream packet length in bytes. More...
uint32_t	getHeaderByteLength (void) const
	Return the bitstream header length in bytes. More...

Static Public Member Functions
static uint32_t	makeSubfield (ERegister inRegister, const std::string &inSubfield, const std::string &inSetting)
	Return the masked value for a subfield of the specified register. More...
static bool	expect (std::istream &inStream, uint8_t inExpected)
	Look for the expected uint8_t in the stream and return true if it matches. More...
static bool	expect (std::istream &inStream, uint16_t inExpected)
	Look for the expected uint16_t in the stream and return true if it matches. More...
static bool	expect (std::istream &inStream, uint32_t inExpected)
	Look for the expected uint32_t in the stream and return true if it matches. More...
static void	readHeaderString (std::istream &inStream, string &outString)
	Read and return a bitstream header string. More...
static bool	readHeader (std::istream &inStream, string &outDesignName, string &outDeviceName, string &outDesignDate, string &outDesignTime, uint32_t &outBitstreamLength, uint32_t &outHeaderLength)
	Read a bitstream header, and return its fields. More...
static void	writeSubfieldSettings (std::ostream &inStream, uint32_t inWord, const Subfield *inSubfields)
	Insert 32 bit subfield settings into an output stream. More...
static void	writeSubfieldSettings (std::ostream &inStream, uint16_t inWord, const Subfield *inSubfields)
	Insert 16 bit subfield settings into an output stream. More...

Data Fields
EDevice	mDevice
	Bitstream device enumeration. More...
string	mDesignName
	Header design name. More...
string	mDeviceName
	Header device name. More...
string	mDesignDate
	Header design date. More...
string	mDesignTime
	Header design time. More...
uint32_t	mBitstreamByteLength
	Bitstream packet length in bytes. More...
uint32_t	mHeaderByteLength
	Header length in bytes. More...
ColumnDefVector	mColumnDefs
	Column type widths. More...
TileTypeNameToColumnType	mTileTypeNameToColumnType
TileTypeIndexToColumnType	mTileTypeIndexToColumnType
DeviceInfo	mDeviceInfo
	Device information. More...
FrameSet< VirtexFrame >	mBlock [Bitstream::eBlockTypeCount]
	FrameSets for each of the eight block types. More...

Protected Types
typedef boost::uint32_t	uint32_t
	Imported type name. More...
typedef std::map< uint32_t, Virtex7::FrameAddress >	FrameIndexToAddress
	Map from frame index to frame address. More...
typedef std::map < Virtex7::FrameAddress, uint32_t >	FrameAddressToIndex
	Map from frame address to frame index. More...
typedef std::vector< uint32_t >	IndexVector
	Vector of frame indexes. More...
typedef std::map< uint32_t, uint32_t >	BitColumnToXdlColumn
	Map from bitstream column index to XDL column index. More...
typedef std::vector < FrameRowDesignator >	FrameRowDesignatorVector
	Vector of FrameRowDesignator entries. More...

Protected Member Functions
void	setRowCounts (const string &inDeviceName)
	Set the number of top and bottom bitstream rows. More...
VirtexFrameBlocks	getBitstreamFrames (uint32_t inSerialFrameRow, uint32_t inBitCol, uint32_t inBlockCount=eBlockTypeCount)
	Returns frames for queried bitstream coordinates inSerialFrameRow The frame row as indexed starting from top row zero and incrementing toward the top of the device, and then continuing from bottom row zero and incrementing toward the bottom of the device. More...
VirtexFrameBlocks	getXdlFrames (uint32_t inSerialFrameRow, uint32_t inColumnVectorBase, uint32_t inXdlCol, uint32_t inBlockCount=eBlockTypeCount)
	Returns frames for queried XDL coordinates inSerialFrameRow The frame row as indexed starting from top row zero and incrementing toward the top of the device, and then continuing from bottom row zero and incrementing toward the bottom of the device. More...
void	unimplemented (std::string inName)
	Reports the named function as not yet implemented in the current architecture. More...
virtual void	updateCrc16 (torc::common::DeviceDesignator::EFamily inFamily)
	Update CRC-16 packets. More...
virtual void	updateCrc32 (torc::common::DeviceDesignator::EFamily inFamily)
	Update CRC-32 packets. More...
template<class ARCH >
void	readFramePackets4567 (uint32_t inBlockFrameIndexBounds[], std::map< typename ARCH::FrameAddress, uint32_t > &inFrameAddressToIndex, std::map< uint32_t, typename ARCH::FrameAddress > &inFrameIndexToAddress)
	Read frame packets in for Virtex4/5/6/7 devices. More...
template<class ARCH >
VirtexPacketVector::iterator	deleteFramePackets4567 (void)
	Discard the existing frame packets for Virtex4/5/6/7 devices. More...
template<class ARCH >
VirtexPacketVector	generateFullBitstreamPackets4567 (uint32_t inBlockFrameIndexBounds[])
	Return a packet vector with full frame data for Virtex4/5/6/7 devices. More...
template<class ARCH >
VirtexPacketVector	generatePartialBitstreamPackets4567 (EFrameInclude inFrameInclusion, std::map< typename ARCH::FrameAddress, uint32_t > &inFrameAddressToIndex, std::map< uint32_t, typename ARCH::FrameAddress > &inFrameIndexToAddress)
	Return a packet vector with partial frame data for Virtex4/5/6/7 devices. More...

Protected Attributes
uint32_t	mTopRowCount
	The number of top bitstream rows. More...
uint32_t	mBottomRowCount
	The number of bottom bitstream rows. More...
FrameIndexToAddress	mFrameIndexToAddress
	Map of frame indexes to frame addresses. More...
FrameAddressToIndex	mFrameAddressToIndex
	Map of frame addresses to frame indexes. More...
IndexVector	mBitColumnIndexes [Virtex7::eFarBlockTypeCount]
	Vector to store frame indexes of XDL columns. More...
IndexVector	mXdlColumnIndexes [Virtex7::eFarBlockTypeCount]
	Vector to store frame indexes of Bitstream columns. More...
uint32_t	mBlockFrameIndexBounds [Virtex7::eFarBlockTypeCount]
	Array to hold frame index boundaries for blocks. More...
BitColumnToXdlColumn	mBitColumnToXdlColumn
	Map of bitstream column indexes to XDL column indexes. More...
uint32_t	mFrameRowCount
	Number of frame rows. More...
FrameRowDesignatorVector	mXdlRowToFrameRowDesignator
	Vector of FrameRowDesignator entries for each XDL row. More...
VirtexFrameBlocks	mFrameBlocks
	Input Frame blocks. More...

Static Protected Attributes
static const char *	sPacketTypeName [ePacketTypeCount]
	Configuration controller registers. More...
static const char *	sOpcodeName [eOpcodeCount]
	Packet Opcode names. More...
static const char *	sRegisterName [eRegisterCount]
	Configuration Register names. More...
static const char *	sCommandName [eCommandCount]
	Configuration Command names. More...
static const Subfield	sCOR0 []
	Configurations Options Register 0 (COR) subfields. More...
static const Subfield	sCOR1 []
	Configurations Options Register 1 (COR) subfields. More...
static const Subfield	sSTAT []
	Status Register (STAT) subfields. More...
static const Subfield	sCTL0 []
	Control Register 0 (CTL) subfields. More...
static const Subfield	sCTL1 []
	Control Register 1 (CTL) subfields. More...
static const Subfield	sMASK0 []
	Control Mask Register (MASK) subfields. More...
static const Subfield	sWBSTAR []
	Warm Boot Start Address Register (WBSTAR) subfields. More...
static const Subfield	sTIMER []
	Watchdog Timer Register (TIMER) subfields. More...
static const Subfield	sBOOTSTS []
	Boot History Status Register (BOOTSTS) subfields. More...

Friends
class	torc::bitstream::bitstream::Virtex7UnitTest
class	torc::bitstream::bitstream::Virtex7FarUnitTest
class	torc::bitstream::bitstream::Zynq7000DebugUnitTest
void	torc::bitstream::bitstream::testVirtex7Device (const std::string &inDeviceName, const boost::filesystem::path &inWorkingPath)
std::ostream &	operator<< (std::ostream &os, const Virtex7 &rhs)
	Insert the bitstream header into and output stream. More...

Detailed Description

Virtex7 bitstream.

Definition at line 40 of file Virtex7.hpp.

Member Typedef Documentation

typedef std::map<uint32_t, uint32_t> torc::bitstream::Virtex7::BitColumnToXdlColumn

protected

Map from bitstream column index to XDL column index.

Definition at line 395 of file Virtex7.hpp.

typedef torc::common::EDevice torc::bitstream::Bitstream::EDevice

inherited

Imported type name.

Definition at line 64 of file bitstream/Bitstream.hpp.

typedef VirtexFrame torc::bitstream::FrameBlocks< VirtexFrame >::frame_t

inherited

FrameSet frame type.

Definition at line 83 of file FrameSet.hpp.

typedef std::map<Virtex7::FrameAddress, uint32_t> torc::bitstream::Virtex7::FrameAddressToIndex

protected

Map from frame address to frame index.

Definition at line 391 of file Virtex7.hpp.

typedef std::map<uint32_t, Virtex7::FrameAddress> torc::bitstream::Virtex7::FrameIndexToAddress

protected

Map from frame index to frame address.

Definition at line 389 of file Virtex7.hpp.

typedef std::vector<FrameRowDesignator> torc::bitstream::Virtex7::FrameRowDesignatorVector

protected

Vector of FrameRowDesignator entries.

Definition at line 397 of file Virtex7.hpp.

typedef std::vector<uint32_t> torc::bitstream::Virtex7::IndexVector

protected

Vector of frame indexes.

Definition at line 393 of file Virtex7.hpp.

typedef std::string torc::bitstream::Bitstream::string

inherited

Imported type name.

Todo:

Bitstream access needs to be changed from public back to protected.

Definition at line 60 of file bitstream/Bitstream.hpp.

typedef std::map<uint16_t, uint32_t> torc::bitstream::Bitstream::TileTypeIndexToColumnType

inherited

Mapping from tile indexes to column types.

Definition at line 254 of file bitstream/Bitstream.hpp.

typedef std::map<std::string, uint32_t> torc::bitstream::Bitstream::TileTypeNameToColumnType

inherited

Mapping from tile type names to column types.

Definition at line 251 of file bitstream/Bitstream.hpp.

typedef boost::uint16_t torc::bitstream::Bitstream::uint16_t

inherited

Imported type name.

Definition at line 62 of file bitstream/Bitstream.hpp.

typedef boost::uint32_t torc::bitstream::Virtex7::uint32_t

protected

Imported type name.

Definition at line 49 of file Virtex7.hpp.

typedef boost::uint8_t torc::bitstream::Bitstream::uint8_t

inherited

Imported type name.

Definition at line 61 of file bitstream/Bitstream.hpp.

typedef VirtexFrame ::word_t torc::bitstream::FrameBlocks< VirtexFrame >::word_t

inherited

FrameSet word type.

Definition at line 85 of file FrameSet.hpp.

Member Enumeration Documentation

anonymous enum

inherited

The block type count is fixed at eight across all Xilinx architectures.

Enumerator
eBlockTypeCount

Definition at line 44 of file bitstream/Bitstream.hpp.

{ eBlockTypeCount = 8 };

anonymous enum

Assorted Constants.

See Also

WBSTAR Register Description: UG470, v1.1, March 28, 2011, Table 5-31.

Enumerator
eStartAddr
eTimerValue

Definition at line 89 of file Virtex7.hpp.

             {
            eStartAddr =    0x1fffffff,
            eTimerValue =   0x3fffffff,
        };

anonymous enum

Frame length.

Constant frame length of 101 32-bit words for the entire Virtex7 family.

See Also

Frame Address Register (00001): UG470, v1.1, March 28, 2011.

Enumerator
eFrameLength

Definition at line 103 of file Virtex7.hpp.

{ eFrameLength = 101 };

anonymous enum

Number of pad frames after each frame row.

The configuration controller expects two frames of NOPs after each frame row.

Enumerator
eRowPadFrames

Definition at line 106 of file Virtex7.hpp.

{ eRowPadFrames = 2 };

anonymous enum

Number of rows in a clock region.

Enumerator
eClockRegionRows

Definition at line 108 of file Virtex7.hpp.

{ eClockRegionRows = 52 };

enum torc::bitstream::Bitstream::EBitstreamType

inherited

The bitstream type to generate. Use eBitstreamFull to fully reconfigure a device, eBitstreamTypePartialActive to partially reconfigure it while it continues to run, or eBitstreamTypePartialShutdown to partially recongifure it after shutting it down.

Enumerator
eBitstreamTypeFull
eBitstreamTypePartialActive
eBitstreamTypePartialShutdown

Definition at line 49 of file bitstream/Bitstream.hpp.

                            { eBitstreamTypeFull, eBitstreamTypePartialActive, 
            eBitstreamTypePartialShutdown };

enum torc::bitstream::Virtex7::EColumnType

Major Column Types.

These are defined and used for internal purposes only, and are not derived from any Xilinx documentation.

Enumerator
eColumnTypeEmpty
eColumnTypeInt
eColumnTypeBram
eColumnTypeCfg
eColumnTypeClb
eColumnTypeClock
eColumnTypeCmt
eColumnTypeDsp
eColumnTypeGtx
eColumnTypeIoi
eColumnTypeVframe
eColumnTypePss
eColumnTypeCount

Definition at line 97 of file Virtex7.hpp.

                         { eColumnTypeEmpty = 0, eColumnTypeInt, eColumnTypeBram, eColumnTypeCfg, 
            eColumnTypeClb, eColumnTypeClock, eColumnTypeCmt, eColumnTypeDsp, eColumnTypeGtx, 
            eColumnTypeIoi, eColumnTypeVframe, eColumnTypePss, eColumnTypeCount };

enum torc::bitstream::Virtex7::ECommand

Configuration register enumeration.

See Also

Command Register Codes: UG470, v1.1, March 28, 2011, Table 5-21.

Enumerator
eCommandNULL
eCommandWCFG
eCommandMFW
eCommandDGHIGH
eCommandLFRM
eCommandRCFG
eCommandSTART
eCommandRCAP
eCommandRCRC
eCommandAGHIGH
eCommandSWITCH
eCommandGRESTORE
eCommandSHUTDOWN
eCommandGCAPTURE
eCommandDESYNCH
eCommandReserved
eCommandIPROG
eCommandCRCC
eCommandLTIMER
eCommandCount

Definition at line 63 of file Virtex7.hpp.

                      { eCommandNULL = 0, eCommandWCFG, eCommandMFW, eCommandDGHIGH, 
            eCommandLFRM = eCommandDGHIGH, eCommandRCFG, eCommandSTART, eCommandRCAP, eCommandRCRC, 
            eCommandAGHIGH, eCommandSWITCH, eCommandGRESTORE, eCommandSHUTDOWN, eCommandGCAPTURE, 
            eCommandDESYNCH, eCommandReserved, eCommandIPROG, eCommandCRCC, eCommandLTIMER, 
            eCommandCount };

enum torc::bitstream::Virtex7::EFar

Frame Address Register subfields.

See Also

Frame Address Register Description: UG470, v1.1, March 28 2011, Table 5-20.

Enumerator
eFarMaskBlockType
eFarShiftBlockType
eFarMaskTopBottom
eFarShiftTopBottom
eFarMaskRow
eFarShiftRow
eFarMaskMajor
eFarShiftMajor
eFarMaskMinor
eFarShiftMinor

Definition at line 71 of file Virtex7.hpp.

                  {
            eFarMaskBlockType =     0x03800000,     eFarShiftBlockType =    23,         
            eFarMaskTopBottom =     0x00400000,     eFarShiftTopBottom =    22,         
            eFarMaskRow =           0x003e0000,     eFarShiftRow =          17,         
            eFarMaskMajor =         0x0001ff80,     eFarShiftMajor =         7,         
            eFarMaskMinor =         0x0000007f,     eFarShiftMinor =         0
        };

enum torc::bitstream::Virtex7::EFarBlockType

Frame Address Register block type constants.

Enumerator
eFarBlockType0
eFarBlockType1
eFarBlockType2
eFarBlockType3
eFarBlockType4
eFarBlockType5
eFarBlockType6
eFarBlockType7
eFarBlockTypeCount

Definition at line 84 of file Virtex7.hpp.

                           { eFarBlockType0 = 0, eFarBlockType1, eFarBlockType2, eFarBlockType3,     
            eFarBlockType4, eFarBlockType5, eFarBlockType6, eFarBlockType7, eFarBlockTypeCount };

enum torc::bitstream::Virtex7::EFarTopBottom

Frame Address Register top and bottom constants.

See Also

Frame Address Register Description: UG470, v1.1, March 28, 2011, Table 5-20.

Enumerator
eFarTop
eFarBottom

Definition at line 81 of file Virtex7.hpp.

{ eFarTop = 0, eFarBottom = 1 };

enum torc::bitstream::Bitstream::EFrameInclude

inherited

The frames to include in a partial bitstream. Use eFrameIncludeOnlyDirtyFrames to include only dirty frames, or eFrameStateAllUsedFrames to include all allocated frames, dirty or not. Note that if not all frames were allocated, eFrameStateAllUsedFrames is not the same as a full bitstream.

Enumerator
eFrameIncludeOnlyDirtyFrames
eFrameIncludeAllUsedFrames

Definition at line 56 of file bitstream/Bitstream.hpp.

{ eFrameIncludeOnlyDirtyFrames, eFrameIncludeAllUsedFrames };

enum torc::bitstream::VirtexPacketConstants::EOpcode

inherited

Packet opcode enumeration.

See Also

Opcode Format: UG191, v3.7, June 24, 2009, Table 6-3.

Enumerator
eOpcodeNOP
eOpcodeRead
eOpcodeWrite
eOpcodeReserved
eOpcodeCount

Definition at line 45 of file VirtexPacket.hpp.

{ eOpcodeNOP = 0, eOpcodeRead, eOpcodeWrite, eOpcodeReserved, eOpcodeCount };

enum torc::bitstream::VirtexPacketConstants::EPacket

inherited

Packet subfields.

See Also

type 1 packet format: UG071, v1.10, April 8, 2008, Table 7-2.

type 2 packet format: UG071, v1.10, April 8, 2008, Table 7-4.

type 1 packet format: XAPP151, v1.7, October 20, 2004, Figure 13.

type 2 packet format: XAPP151, v1.7, October 20, 2004, Figure 14.

Enumerator
ePacketMaskType
ePacketShiftType
ePacketMaskOpcode
ePacketShiftOpcode
ePacketMaskType1Address
ePacketShiftType1Address
ePacketMaskType1Reserved
ePacketShiftType1Reserved
ePacketMaskType1Count
ePacketShiftType1Count
ePacketMaskType2Count
ePacketShiftType2Count

Definition at line 51 of file VirtexPacket.hpp.

                     {
            // generic packet subfields
            ePacketMaskType =           0xe0000000,     ePacketShiftType =          29,
            ePacketMaskOpcode =         0x18000000,     ePacketShiftOpcode =        27,
            // type 1 packet subfields
            ePacketMaskType1Address =   0x07ffe000,     ePacketShiftType1Address =  13,
            ePacketMaskType1Reserved =  0x00001800,     ePacketShiftType1Reserved = 11,
            ePacketMaskType1Count =     0x000007ff,     ePacketShiftType1Count =     0,
            // type 2 packet subfields
            ePacketMaskType2Count =     0x07ffffff,     ePacketShiftType2Count =     0
        };

enum torc::bitstream::VirtexPacketConstants::EPacketType

inherited

Packet type enumeration.

See Also

packet type: UG071, v1.10, April 8, 2008, Tables 7-2 and 7-4.

packet type: XAPP151, v1.7, October 20, 2004, Figure 13, 14.

Enumerator
ePacketType1
ePacketType2
ePacketTypeCount

Definition at line 41 of file VirtexPacket.hpp.

{ ePacketType1 = 1, ePacketType2, ePacketTypeCount = 8 };

enum torc::bitstream::Virtex7::ERegister

Configuration register enumeration.

See Also

Type 1 Packet Registers: UG470, v1.1, March 28, 2011, Table 5-19.

Enumerator
eRegisterCRC
eRegisterFAR
eRegisterFDRI
eRegisterFDRO
eRegisterCMD
eRegisterCTL0
eRegisterMASK
eRegisterSTAT
eRegisterLOUT
eRegisterCOR0
eRegisterMFWR
eRegisterCBC
eRegisterIDCODE
eRegisterAXSS
eRegisterCOR1
eRegisterWBSTAR
eRegisterTIMER
eRegisterBOOTSTS
eRegisterCTL1
eRegisterCount

Definition at line 55 of file Virtex7.hpp.

                       { eRegisterCRC = 0, eRegisterFAR, eRegisterFDRI, eRegisterFDRO, 
            eRegisterCMD, eRegisterCTL0, eRegisterMASK, eRegisterSTAT, eRegisterLOUT, 
            eRegisterCOR0, eRegisterMFWR, eRegisterCBC, eRegisterIDCODE, eRegisterAXSS, 
            eRegisterCOR1, eRegisterWBSTAR = 16, eRegisterTIMER, eRegisterBOOTSTS = 22, 
            eRegisterCTL1 = 24, eRegisterCount };

enum torc::bitstream::VirtexPacketConstants::ESynchronization

inherited

Synchronization words.

See Also

Configuration Sequence: UG191, v3.7, June 24, 2009, Table 6-15.

Configuration Sequence: UG071, v1.10, April 8, 2008, Table 7-11.

Configuration Sequence: XAPP511, v1.7, October 20, 2004, Figure 23.

Enumerator
eSynchronizationDummy
eSynchronizationSync
eSynchronizationBusWidthSync
eSynchronizationBusWidthDetect

Definition at line 67 of file VirtexPacket.hpp.

                              {
            eSynchronizationDummy =             0xffffffff,
            eSynchronizationSync =              0xaa995566,
            eSynchronizationBusWidthSync =      0x000000bb,
            eSynchronizationBusWidthDetect =    0x11220044
        };

Constructor & Destructor Documentation

torc::bitstream::Virtex7::Virtex7 ( void  )

inline

Basic Constructor.

Definition at line 150 of file Virtex7.hpp.

                      : VirtexBitstream(), mTopRowCount(0), mBottomRowCount(0), mFrameRowCount(0) {     
//          for(int i = 0; i < eRegisterCount; i++) mRegister[i] =0;
            for(int i = 0; i < eFarBlockTypeCount; i++) mBlockFrameIndexBounds[i] = 0;
            // initialize miscellaneous variables
            mFrameRowCount = 0;
            // initialize the column type widths for this family
            mColumnDefs.resize(eColumnTypeCount);
            mColumnDefs[eColumnTypeEmpty]   = ColumnDef("Empty",    0,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeInt]     = ColumnDef("Int",      0,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeBram]    = ColumnDef("Bram",    28,128,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeCfg]     = ColumnDef("Cfg",     36,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeClb]     = ColumnDef("Clb",     36,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeClock]   = ColumnDef("Clock",   30,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeCmt]     = ColumnDef("Cmt",     30,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeDsp]     = ColumnDef("Dsp",     28,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeGtx]     = ColumnDef("Gtx",     32,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeIoi]     = ColumnDef("Ioi",     42,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypeVframe]  = ColumnDef("Vframe",  30,  0,  0,  0,  0,  0,  0,  0);
            mColumnDefs[eColumnTypePss]     = ColumnDef("Pss",      0,  0,  0,  0,  0,  0,  0,  0);
            // map type type names to column types
            mTileTypeNameToColumnType["INT_L"]      = eColumnTypeInt;
            mTileTypeNameToColumnType["INT_R"]      = eColumnTypeInt;
            mTileTypeNameToColumnType["BRAM_L"]     = eColumnTypeBram;
            mTileTypeNameToColumnType["BRAM_R"]     = eColumnTypeBram;
            mTileTypeNameToColumnType["CFG_CENTER_TOP"] = eColumnTypeCfg;
            mTileTypeNameToColumnType["CFG_CENTER_BOT"] = eColumnTypeCfg;
            mTileTypeNameToColumnType["MONITOR_TOP_PELE1"] = eColumnTypeCfg;
            mTileTypeNameToColumnType["CLBLL_L"]    = eColumnTypeClb;
            mTileTypeNameToColumnType["CLBLL_R"]    = eColumnTypeClb;
            mTileTypeNameToColumnType["CLBLM_L"]    = eColumnTypeClb;
            mTileTypeNameToColumnType["CLBLM_R"]    = eColumnTypeClb;
            mTileTypeNameToColumnType["INT_FEEDTHRU_1"] = eColumnTypeClb;
            mTileTypeNameToColumnType["CMT_FIFO_L"] = eColumnTypeCmt;
            mTileTypeNameToColumnType["CMT_FIFO_R"] = eColumnTypeCmt;
            mTileTypeNameToColumnType["CLK_FEED"]   = eColumnTypeClock;
            mTileTypeNameToColumnType["DSP_L"]      = eColumnTypeDsp;
            mTileTypeNameToColumnType["DSP_R"]      = eColumnTypeDsp;
            mTileTypeNameToColumnType["GTP_COMMON"] = eColumnTypeGtx;
            mTileTypeNameToColumnType["GTP_COMMON_MID_LEFT"] = eColumnTypeGtx;
            mTileTypeNameToColumnType["GTP_COMMON_MID_RIGHT"] = eColumnTypeGtx;
            mTileTypeNameToColumnType["GTX_COMMON"] = eColumnTypeGtx;
            mTileTypeNameToColumnType["GTH_COMMON"] = eColumnTypeGtx;
            mTileTypeNameToColumnType["HCLK_IOI"]   = eColumnTypeIoi;
            mTileTypeNameToColumnType["HCLK_IOI3"]  = eColumnTypeIoi;
            mTileTypeNameToColumnType["VFRAME"]     = eColumnTypeVframe;
            mTileTypeNameToColumnType["PSS1"]       = eColumnTypePss;
            mTileTypeNameToColumnType["PSS4"]       = eColumnTypePss;
        }

Member Function Documentation

void torc::bitstream::VirtexBitstream::append ( const VirtexPacketVector &  inVector )

inlineinherited

Append the contents of a packet vector to the end of the bitstream.

Definition at line 134 of file VirtexBitstream.hpp.

                                                        {
            VirtexPacketVector::insert(end(), inVector.begin(), inVector.end());
        }

void torc::bitstream::Bitstream::cleanDateAndTime ( void  )

inlineinherited

Clean up the header date and time by replacing embedded spaces with zeros.

Definition at line 183 of file bitstream/Bitstream.hpp.

                                    {
            // some versions of the tools leave spaces inside the date and time fields
            size_t pos = 0;
            while((pos = mDesignDate.find(' ', pos)) != string::npos) mDesignDate[pos] = '0';
            pos = 0;
            while((pos = mDesignTime.find(' ', pos)) != string::npos) mDesignTime[pos] = '0';
        }

Here is the caller graph for this function:

virtual VirtexPacketVector::iterator torc::bitstream::Virtex7::deleteFramePackets ( void  )

inlinevirtual

Discard the existing frame packets and return an iterator to the start position.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 229 of file Virtex7.hpp.

                                                                    {
            return deleteFramePackets4567<Virtex7>();
        }

template<class ARCH >

VirtexPacketVector::iterator torc::bitstream::VirtexBitstream::deleteFramePackets4567 ( void  )

protectedinherited

Discard the existing frame packets for Virtex4/5/6/7 devices.

Todo:

Throw some meaningful exception

Definition at line 213 of file VirtexBitstream.cpp.

        {
        // walk the bitstream and look for frame packet boundaries
        // we begin with the first FAR write, and end before the first CRC write after an FDRI write
        iterator b = begin();
        iterator p = b;
        iterator e = end();
        iterator start = e;
        iterator stop = b;
        iterator fdri = b;
        while(p < e) {
            // look up the current packet
            const VirtexPacket& packet = *p;
            // start from the first FAR write
            if(start == e && packet.isWrite() && packet.getAddress() == ARCH::eRegisterFAR) {
                start = p;
            }
            // remember the last FDRI write (including a trailing Type 2 write if present)
            if(packet.isWrite() && packet.getAddress() == ARCH::eRegisterFDRI) {
                fdri = p;
                if((p+1)->isWrite() && (p+1)->isType2()) fdri++;
            }
            // stop on the first CRC after the last FDRI write
            // (Beware: the zero "address" of a Type 2 packet looks like the CRC register)
            if(stop < fdri && packet.isWrite() && packet.isType1() 
                && packet.getAddress() == ARCH::eRegisterCRC) {
                stop = p;
            }
            p++;
        }
        // look for anything unexpected
        p = start;
        while(p < stop) {
            // look up the current packet
            const VirtexPacket& packet = *p++;
            // abort if we find anything unexpected
            if(start < e && stop > b && !(
                packet.isNop() || (
                packet.isWrite() && (
                    packet.getAddress() == ARCH::eRegisterFAR ||
                    packet.getAddress() == ARCH::eRegisterLOUT ||
                    packet.getAddress() == ARCH::eRegisterFDRI ||
                    packet.getAddress() == ARCH::eRegisterCRC ||
                    (packet.getAddress() == ARCH::eRegisterCMD && packet[1] == ARCH::eCommandWCFG)
            )))) {
                /// \todo Throw some meaningful exception
                std::cerr << "Unable to safely distinguish frame packets." << std::endl;
                return e;
            }
        }
        // if we found the expected FAR -> FDRI -> CRC structure, delete the frame packets
        if(start < stop && b < stop) {
            erase(start, stop);
            return start;
        }
        // if we didn't find frame packets or delete anything, return the end iterator
        return e;
    }

Here is the call graph for this function:

static bool torc::bitstream::Bitstream::expect ( std::istream &  inStream, uint8_t  inExpected  )

inlinestaticinherited

Look for the expected uint8_t in the stream and return true if it matches.

Definition at line 89 of file bitstream/Bitstream.hpp.

                                                                     {
            // read the actual data from the stream
            uint8_t actual = 0;
            inStream.read((char*) &actual, sizeof(actual));
            // return equality
            return inExpected == actual;
        }

Here is the caller graph for this function:

static bool torc::bitstream::Bitstream::expect ( std::istream &  inStream, uint16_t  inExpected  )

inlinestaticinherited

Look for the expected uint16_t in the stream and return true if it matches.

Definition at line 97 of file bitstream/Bitstream.hpp.

                                                                      {
            // read the actual data from the stream
            uint16_t actual = 0;
            inStream.read((char*) &actual, sizeof(actual));
            // return equality
            return inExpected == ntohs(actual);
        }

static bool torc::bitstream::Bitstream::expect ( std::istream &  inStream, uint32_t  inExpected  )

inlinestaticinherited

Look for the expected uint32_t in the stream and return true if it matches.

Definition at line 105 of file bitstream/Bitstream.hpp.

                                                                      {
            // read the actual data from the stream
            uint32_t actual = 0;
            inStream.read((char*) &actual, sizeof(actual));
            // return equality
            return inExpected == ntohl(actual);
        }

void torc::bitstream::VirtexBitstream::generateBitstream ( EBitstreamType  inBitstreamType = eBitstreamTypeFull, EFrameInclude  inFrameInclusion = eFrameIncludeAllUsedFrames  )

virtualinherited

Discard existing packets and generate bitstream packets from frame data. By default this generates packets for a full bitstream.

Parameters

inBitstreamType	The type of bitstream to generate: full, active partial, or shutdown partial.
inFrameInclusion	The type of frames to include in partial bitstreams: only dirty frames or all frames.

Definition at line 58 of file VirtexBitstream.cpp.

                                        {
        // discard all packets
        clear();
        if(inBitstreamType == eBitstreamTypeFull) {
            // generate the prefix
            append(generateFullBitstreamPrefix());
            // generate the frame packets
            append(generateFullBitstreamPackets());
            // generate the suffix
            append(generateFullBitstreamSuffix());
        } else {
            // generate the prefix
            append(generatePartialBitstreamPrefix(inBitstreamType));
            // generate the frame packets
            append(generatePartialBitstreamPackets(inFrameInclusion));
            // generate the suffix
            append(generatePartialBitstreamSuffix(inBitstreamType));
        }
    }

virtual VirtexPacketVector torc::bitstream::Virtex7::generateFullBitstreamPackets ( void  )

inlinevirtual

Return a packet vector with full frame data.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 233 of file Virtex7.hpp.

                                                                      {
            return generateFullBitstreamPackets4567<Virtex7>(mBlockFrameIndexBounds);
        }

template<class ARCH >

VirtexPacketVector torc::bitstream::VirtexBitstream::generateFullBitstreamPackets4567 ( uint32_t  inBlockFrameIndexBounds[] )

protectedinherited

Return a packet vector with full frame data for Virtex4/5/6/7 devices.

Definition at line 287 of file VirtexBitstream.cpp.

                                            {

        // declare the packet vector and define a NOP packet
        typedef VirtexFrame::word_t word_t;
        VirtexPacketVector packets;
        VirtexPacket nop(VirtexPacket::makeHeader(ePacketType1, eOpcodeNOP, 0, 0));

        // determine the total size of the frames to write
        size_t size = 0;
        for(int i = 0; i < eBlockTypeCount; i++) 
            size += inBlockFrameIndexBounds[i] * getFrameLength();
        word_t* frameContents = new VirtexFrameSet::word_t[size];
        word_t* pos = frameContents;
        // gather the frames to write
        for(int i = 0; i < eBlockTypeCount; i++) {
            // look up the frame set for this block type
            VirtexFrameSet& frameSet = mFrameBlocks.mBlock[i];
            // iterate through the frames in the set and collect the frame words
            VirtexFrameSet::iterator p = frameSet.begin();
            VirtexFrameSet::iterator e = frameSet.end();
            while(p < e) {
                // look up the current frame
                VirtexFrameSharedPtr framePtr = *p++;
                // set up the pointers
                const word_t* wp = framePtr->getWords();
                const word_t* we = wp + framePtr->getLength();
                // and copy the frame words into the new memory
                if(wp) do { *pos++ = *wp++; } while(wp < we); // frames with words allocated
                else do { *pos++ = 0; wp++; } while(wp < we); // frames with no words allocated
            }
        }
        // write the starting frame address
        packets.push_back(VirtexPacket::makeType1Write(ARCH::eRegisterFAR, 0));
        // write the write configuration register command
        packets.push_back(VirtexPacket::makeType1Write(ARCH::eRegisterCMD, ARCH::eCommandWCFG));
        packets.push_back(nop);
        // write 0 bytes to FDRI (in preparation for type 2 write packet)
        packets.push_back(VirtexPacket::makeNullType1Write(ARCH::eRegisterFDRI));
        // write all frames to FDRI
        packets.push_back(VirtexPacket::makeType2Write(size, frameContents));

        // return the packet vector
        return packets;
    }

VirtexPacketVector torc::bitstream::Virtex7::generateFullBitstreamPrefix ( void  )

virtual

Return a packet vector with the full bitstream prefix.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 847 of file Virtex7.cpp.

                                                                {
        //  0000005d: DUMMY
        //  00000061: DUMMY
        //  00000065: DUMMY
        //  00000069: DUMMY
        //  0000006d: DUMMY
        //  00000071: DUMMY
        //  00000075: DUMMY
        //  00000079: DUMMY
        //  0000007d: BUS WIDTH SYNC
        //  00000081: BUS WIDTH DETECT
        //  00000085: DUMMY
        //  00000089: DUMMY
        //  0000008d: SYNC
        //  00000091: NOP x 1
        //  00000095: TYPE1 WRITE TIMER: 00000000 (TimerForUser:Disabled, TimerForConfig:Disabled)
        //  0000009d: TYPE1 WRITE WBSTAR: 00000000 (RevisionSelectTristate:Disabled, 
        //              NextRevisionSelect:00)
        //  000000a5: TYPE1 WRITE CMD NULL
        //  000000ad: NOP x 1
        //  000000b1: TYPE1 WRITE CMD RCRC
        //  000000b9: NOP x 2
        //  000000c1: TYPE1 WRITE [UNKNOWN REG 19]: 00000000
        //  000000c9: TYPE1 WRITE COR0: 02003fe5 (DONE_status:DonePin, DonePipe:Yes, DriveDone:No, 
        //              Capture:Continuous, ConfigRate:[UNKNOWN 0], StartupClk:Cclk, DONE_cycle:4, 
        //              Match_cycle:NoWait, LCK_cycle:No Wait, GTS_cycle:5, GWE_cycle:6)
        //  000000d1: TYPE1 WRITE COR1: 00000000 (PersistDeassertAtDesynch:Disabled, 
        //              ActionReadbackCRC:Continue, InitAsCRCErrorPin:Disabled, 
        //              ContinuousReadbackCRC:Enabled, BPI_1st_read_cycle:1, BPI_page_size:1)
        //  000000d9: TYPE1 WRITE IDCODE: 03651093
        //  000000e1: TYPE1 WRITE CMD SWITCH
        //  000000e9: NOP x 1
        //  000000ed: TYPE1 WRITE MASK: 00000401 (EFUSE_key:Protected, ICAP_sel:Protected, 
        //              OverTempPowerDown:Protected, GLUTMASK:Protected, FARSRC:Protected, 
        //              Encrypt:Protected, Security:Protected, Persist:Protected, 
        //              GTS_USER_B:Writable)
        //  000000f5: TYPE1 WRITE CTL0: 00000501 (EFUSE_key:No, ICAP_sel:Top, 
        //              OverTempPowerDown:Disable, GLUTMASK:Dynamic, FARSRC:FAR, Encrypt:No, 
        //              Security:None, Persist:No, GTS_USER_B:IoActive)
        //  000000fd: TYPE1 WRITE MASK: 00000000 ()
        //  00000105: TYPE1 WRITE CTL1: 00000000 ()
        //  0000010d: NOP x 8

        // declare the packet vector and define a NOP packet
        typedef VirtexFrame::word_t word_t;
        VirtexPacketVector packets;
        VirtexPacket nop(VirtexPacket::makeHeader(ePacketType1, eOpcodeNOP, 0, 0));
        VirtexPacket dummy(eSynchronizationDummy);
        // dummy words
        packets.insert(packets.end(), 8, dummy);
        // bus width detect
        packets.push_back(VirtexPacket(eSynchronizationBusWidthSync));
        packets.push_back(VirtexPacket(eSynchronizationBusWidthDetect));
        packets.push_back(dummy);
        packets.push_back(dummy);
        // sync
        packets.push_back(VirtexPacket(eSynchronizationSync));
        packets.push_back(nop);
        // watchdog timer
        packets.push_back(VirtexPacket::makeType1Write(eRegisterTIMER, 0));
        // warm boot register
        packets.push_back(VirtexPacket::makeType1Write(eRegisterWBSTAR, 0));
        // NULL command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandNULL));
        packets.push_back(nop);
        // reset CRC command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandRCRC));
        packets.push_back(nop);
        packets.push_back(nop);
        // undocumented register 19
        packets.push_back(VirtexPacket::makeType1Write(19, 0));
        // configuration options register 0
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCOR0, 
                makeSubfield(eRegisterCOR0, "DONE_status", "DonePin") |
                makeSubfield(eRegisterCOR0, "DonePipe", "Yes") |
                makeSubfield(eRegisterCOR0, "DriveDone", "No") |
                makeSubfield(eRegisterCOR0, "Capture", "Continuous") |
                makeSubfield(eRegisterCOR0, "ConfigRate", "[UNKNOWN 0]") |
                makeSubfield(eRegisterCOR0, "StartupClk", "Cclk") |
                makeSubfield(eRegisterCOR0, "DONE_cycle", "4") |
                makeSubfield(eRegisterCOR0, "Match_cycle", "NoWait") |
                makeSubfield(eRegisterCOR0, "LCK_cycle", "NoWait") |
                makeSubfield(eRegisterCOR0, "GTS_cycle", "5") |
                makeSubfield(eRegisterCOR0, "GWE_cycle", "6") |
            0));
        // configuration options register 1
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCOR1, 
                makeSubfield(eRegisterCOR1, "PersistDeassertAtDesynch", "Disabled") |
                makeSubfield(eRegisterCOR1, "ActionReadbackCRC", "Continue") |
                makeSubfield(eRegisterCOR1, "InitAsCRCErrorPin", "Disabled") |
                makeSubfield(eRegisterCOR1, "ContinuousReadbackCRC", "Enabled") |
                makeSubfield(eRegisterCOR1, "BPI_1st_read_cycle", "1") |
                makeSubfield(eRegisterCOR1, "BPI_page_size", "1") |
            0));
        // write the ID code
        packets.push_back(VirtexPacket::makeType1Write(eRegisterIDCODE, 0x00000000));
        // clock and rate switch command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandSWITCH));
        packets.push_back(nop);
        // control register 0 mask
        packets.push_back(VirtexPacket::makeType1Write(eRegisterMASK, 
                makeSubfield(eRegisterMASK, "EFUSE_key", "Protected") |
                makeSubfield(eRegisterMASK, "ICAP_sel", "Protected") |
                makeSubfield(eRegisterMASK, "OverTempPowerDown", "Protected") |
                makeSubfield(eRegisterMASK, "GLUTMASK", "Protected") |
                makeSubfield(eRegisterMASK, "FARSRC", "Protected") |
                makeSubfield(eRegisterMASK, "Encrypt", "Protected") |
                makeSubfield(eRegisterMASK, "Security", "Protected") |
                makeSubfield(eRegisterMASK, "Persist", "Protected") |
                makeSubfield(eRegisterMASK, "GTS_USER_B", "Writable") |
            0));
        // control register 0
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCTL0, 
                makeSubfield(eRegisterCTL0, "EFUSE_key", "NO") |
                makeSubfield(eRegisterCTL0, "ICAP_sel", "Top") |
                makeSubfield(eRegisterCTL0, "OverTempPowerDown", "Disable") |
                makeSubfield(eRegisterCTL0, "GLUTMASK", "Dynamic") |
                makeSubfield(eRegisterCTL0, "FARSRC", "FAR") |
                makeSubfield(eRegisterCTL0, "Encrypt", "No") |
                makeSubfield(eRegisterCTL0, "Security", "None") |
                makeSubfield(eRegisterCTL0, "Persist", "No") |
                makeSubfield(eRegisterCTL0, "GTS_USER_B", "IoActive") |
            0));
        // control register 1 mask
        packets.push_back(VirtexPacket::makeType1Write(eRegisterMASK, 0));
        // control register 1
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCTL1, 0));
        // more NOPs
        packets.insert(packets.end(), 8, nop);
        // return the packet vector
        return packets;
    }

Here is the call graph for this function:

VirtexPacketVector torc::bitstream::Virtex7::generateFullBitstreamSuffix ( void  )

virtual

Return a packet vector with the full bitstream suffix.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 980 of file Virtex7.cpp.

                                                                {
        //  00ae95cd: TYPE1 WRITE CRC: 9f18b580
        //  00ae95d1: NOP x 2
        //  00ae95d9: TYPE1 WRITE CMD GRESTORE
        //  00ae95e1: NOP x 1
        //  00ae95e5: TYPE1 WRITE CMD DGHIGH/LFRM
        //  00ae95ed: NOP x 100
        //  00ae977d: TYPE1 WRITE CMD START
        //  00ae9785: NOP x 1
        //  00ae9789: TYPE1 WRITE FAR: 03be0000
        //  00ae9791: TYPE1 WRITE MASK: 00000501 (EFUSE_key:Protected, ICAP_sel:Protected, 
        //              OverTempPowerDown:Protected, GLUTMASK:Writable, FARSRC:Protected, 
        //              Encrypt:Protected, Security:Protected, Persist:Protected, 
        //              GTS_USER_B:Writable)
        //  00ae9799: TYPE1 WRITE CTL0: 00000501 (EFUSE_key:No, ICAP_sel:Top, 
        //              OverTempPowerDown:Disable, GLUTMASK:Dynamic, FARSRC:FAR, Encrypt:No, 
        //              Security:None, Persist:No, GTS_USER_B:IoActive)
        //  00ae97a1: TYPE1 WRITE CRC: e3ad7ea5
        //  00ae97a9: NOP x 2
        //  00ae97b1: TYPE1 WRITE CMD DESYNCH
        //  00ae97b9: NOP x 400

        // declare the packet vector and define a NOP packet
        typedef VirtexFrame::word_t word_t;
        VirtexPacketVector packets;
        VirtexPacket nop(VirtexPacket::makeHeader(ePacketType1, eOpcodeNOP, 0, 0));
        // write a placeholder CRC value
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCRC, 0));
        packets.push_back(nop);
        packets.push_back(nop);
        // restore command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandGRESTORE));
        packets.push_back(nop);
        // last frame command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandLFRM));
        packets.insert(packets.end(), 100, nop);
        // start command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandSTART));
        packets.push_back(nop);
        // frame address register
        packets.push_back(VirtexPacket::makeType1Write(eRegisterFAR, 
            eFarMaskBlockType | eFarMaskRow)); // is this what the configuration controller wants?
        // control register 0 mask
        packets.push_back(VirtexPacket::makeType1Write(eRegisterMASK, 
                makeSubfield(eRegisterMASK, "EFUSE_key", "Protected") |
                makeSubfield(eRegisterMASK, "ICAP_sel", "Protected") |
                makeSubfield(eRegisterMASK, "OverTempPowerDown", "Protected") |
                makeSubfield(eRegisterMASK, "GLUTMASK", "Protected") |
                makeSubfield(eRegisterMASK, "FARSRC", "Protected") |
                makeSubfield(eRegisterMASK, "Encrypt", "Protected") |
                makeSubfield(eRegisterMASK, "Security", "Protected") |
                makeSubfield(eRegisterMASK, "Persist", "Protected") |
                makeSubfield(eRegisterMASK, "GTS_USER_B", "Writable") |
            0));
        // control register 0
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCTL0, 
                makeSubfield(eRegisterCTL0, "EFUSE_key", "NO") |
                makeSubfield(eRegisterCTL0, "ICAP_sel", "Top") |
                makeSubfield(eRegisterCTL0, "OverTempPowerDown", "Disable") |
                makeSubfield(eRegisterCTL0, "GLUTMASK", "Dynamic") |
                makeSubfield(eRegisterCTL0, "FARSRC", "FAR") |
                makeSubfield(eRegisterCTL0, "Encrypt", "No") |
                makeSubfield(eRegisterCTL0, "Security", "None") |
                makeSubfield(eRegisterCTL0, "Persist", "No") |
                makeSubfield(eRegisterCTL0, "GTS_USER_B", "IoActive") |
            0));
        // write the CRC value
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCRC, 0x00000000));
        packets.push_back(nop);
        packets.push_back(nop);
        // desynch command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandDESYNCH));
        packets.insert(packets.end(), 400, nop);
        // return the packet vector
        return packets;
    }

Here is the call graph for this function:

virtual VirtexPacketVector torc::bitstream::Virtex7::generatePartialBitstreamPackets ( EFrameInclude  inFrameInclusion )

inlinevirtual

Return a packet vector with partial frame data.

Parameters

inFrameInclusion

The type of frames to include: only dirty frames or all frames.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 242 of file Virtex7.hpp.

                                                                                                   {
            return generatePartialBitstreamPackets4567<Virtex7>(inFrameInclusion, 
                mFrameAddressToIndex, mFrameIndexToAddress);
        }

template<class ARCH >

VirtexPacketVector torc::bitstream::VirtexBitstream::generatePartialBitstreamPackets4567 ( EFrameInclude  inFrameInclusion, std::map< typename ARCH::FrameAddress, uint32_t > &  inFrameAddressToIndex, std::map< uint32_t, typename ARCH::FrameAddress > &  inFrameIndexToAddress  )

protectedinherited

Return a packet vector with partial frame data for Virtex4/5/6/7 devices.

Todo:

mFrameIndexToAddress.size() is too short because excludes pad frames

Definition at line 367 of file VirtexBitstream.cpp.

                                                                            {
        // clean up the template parameters
        typedef typename ARCH::FrameAddress FrameAddress;
        typedef std::map<FrameAddress, uint32_t> FrameAddressToIndex;
        typedef std::map<uint32_t, FrameAddress> FrameIndexToAddress;

        // declare the packet vector and define a NOP packet
        typedef VirtexFrame::word_t word_t;
        VirtexPacketVector packets;
        VirtexPacket nop(VirtexPacket::makeHeader(ePacketType1, eOpcodeNOP, 0, 0));

        // write the starting frame address
        packets.push_back(VirtexPacket::makeType1Write(ARCH::eRegisterFAR, 0));
        // write the write configuration register command
        packets.push_back(VirtexPacket::makeType1Write(ARCH::eRegisterCMD, ARCH::eCommandWCFG));
        packets.push_back(nop);

        // iterate through the frame blocks looking for groups of contiguous frames that are in use
        bool empty = true;
        uint32_t index = 0;
        uint32_t blockStart = 0;
        for(int i = 0; i < eBlockTypeCount; i++) {
            blockStart += index;
            index = 0;
            bool started = false;
            uint32_t startIndex = 0;
            // look up the frame set for this block type
            VirtexFrameSet& frameSet = mFrameBlocks.mBlock[i];
            // iterate through the frames in the set and add up their lengths
            VirtexFrameSet::iterator p = frameSet.begin();
            VirtexFrameSet::iterator e = frameSet.end();
            while(p < e) {
                // look up the current frame
                VirtexFrameSharedPtr framePtr = *p++;
                // determine whether the frame fits inclusion criteria
                    // we include dirty frames, we include clean frames if permitted by the caller, 
                    // and if we are collecting frames and we encounter pad frames, we include them,
                    // but we stop collecting if we reach the last frame in the set
                /// \todo mFrameIndexToAddress.size() is too short because excludes pad frames
                bool include = p < e 
                    && (
                        framePtr->isDirty() 
                        || (inFrameInclusion == eFrameIncludeAllUsedFrames && framePtr->isUsed()) 
                        || (started && blockStart + index < inFrameIndexToAddress.size() && 
                            inFrameIndexToAddress.find(blockStart + index) 
                                == inFrameIndexToAddress.end())
                    );
                // if we are accumulating frames and this frame doesn't meet the criteria, process 
                // the collection of frames and stop collecting
                if((started && !include)) {
                    started = false;
                    uint32_t stopIndex = index + (p == e ? 1 : 0);
                    uint32_t currentIndex = startIndex;
                    // std::cerr << "    stopped at: " << stopIndex << std::endl;
                    // include two trailing pad frames if appropriate
                    if(inFrameIndexToAddress.find(blockStart + stopIndex + 1) 
                        == inFrameIndexToAddress.end()) {
                        stopIndex++;
                        if(inFrameIndexToAddress.find(blockStart + stopIndex + 1) 
                            == inFrameIndexToAddress.end())
                            stopIndex++;
                    }
                    // determine the length of the contiguous block
                    size_t size = (stopIndex - startIndex) * getFrameLength();
                    // allocate a word array
                    word_t* frameContents = new VirtexFrameSet::word_t[size];
                    word_t* pos = frameContents;
                    while(currentIndex < stopIndex) {
                        // look up the current frame
                        VirtexFrameSharedPtr framePtr = mFrameBlocks.mBlock[i][currentIndex];
                        // set up the pointers
                        const word_t* wp = framePtr->getWords();
                        const word_t* we = wp + framePtr->getLength();
                        // and copy the frame words into the new memory
                        if(wp) do { *pos++ = *wp++; } while(wp < we); // frames with words
                        else do { *pos++ = 0; wp++; } while(wp < we); // frames with no words
                        currentIndex++;
                    }
                    // write the starting frame address
                    packets.push_back(VirtexPacket::makeType1Write(ARCH::eRegisterFAR, 
                        inFrameIndexToAddress[blockStart + startIndex]));
                    packets.push_back(nop);
                    // if the size is more than 2048 words, we have to use a Type 2 write
                    if(size > 2048) {
                        // write 0 bytes to FDRI (in preparation for type 2 write packet)
                        packets.push_back(VirtexPacket::makeNullType1Write(ARCH::eRegisterFDRI));
                        // write all frames to FDRI
                        packets.push_back(VirtexPacket::makeType2Write(size, frameContents));
                    } else {
                        // write all frames to FDRI
                        packets.push_back(VirtexPacket::makeType1Write(ARCH::eRegisterFDRI, size, 
                            frameContents));
                    }
                    if(size) empty = false;
                // if we are not collecting, but we encounter a frame to include, begin collecting
                } else if(!started && include) {
                    // std::cerr << "    started at: " << index << std::endl;
                    startIndex = index;
                    started = true;
                }
                // increment the frame index
                index++;
            }
        }

        // if we generated no frame contents, discard the wrapper packets
        if(empty) packets.clear();
        // return the packet vector
        return packets;
    }

VirtexPacketVector torc::bitstream::Virtex7::generatePartialBitstreamPrefix ( EBitstreamType  inBitstreamType )

virtual

Return a packet vector with the partial bitstream prefix.

Parameters

inBitstreamType

The type of partial bitstream to generate: active or shutdown.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 1057 of file Virtex7.cpp.

                                                                                             {
        //  Packets marked S pertain to shutdown bitstreams only
        //      0000005d: DUMMY
        //      00000061: DUMMY
        //      00000065: DUMMY
        //      00000069: DUMMY
        //      0000006d: DUMMY
        //      00000071: DUMMY
        //      00000075: DUMMY
        //      00000079: DUMMY
        //      0000007d: BUS WIDTH SYNC
        //      00000081: BUS WIDTH DETECT
        //      00000085: DUMMY
        //      00000089: DUMMY
        //      0000008d: SYNC
        //      00000091: NOP x 1
        //      00000095: TYPE1 WRITE CMD RCRC
        //      0000009d: NOP x 2
        //      000000a5: TYPE1 WRITE IDCODE: 03651093
        //  S   000000ad: TYPE1 WRITE COR0: 02003fe5 (DONE_status:DonePin, DonePipe:Yes, 
        //                  DriveDone:No, Capture:Continuous, ConfigRate:[UNKNOWN 0], 
        //                  StartupClk:Cclk, DONE_cycle:4, Match_cycle:NoWait, LCK_cycle:No Wait, 
        //                  GTS_cycle:5, GWE_cycle:6)
        //  S   000000b5: TYPE1 WRITE CMD SHUTDOWN
        //  S   000000bd: NOP x 1
        //  S   000000c1: TYPE1 WRITE CRC: 6f322c8f
        //  S   000000c9: NOP x 4
        //  S   000000d9: TYPE1 WRITE CMD AGHIGH
        //  S   000000e1: NOP x 1
        //      000000e5: TYPE1 WRITE CMD NULL

        // declare the packet vector and define a NOP packet
        typedef VirtexFrame::word_t word_t;
        VirtexPacketVector packets;
        VirtexPacket nop(VirtexPacket::makeHeader(ePacketType1, eOpcodeNOP, 0, 0));
        VirtexPacket dummy(eSynchronizationDummy);
        // dummy words
        packets.insert(packets.end(), 8, dummy);
        // bus width detect
        packets.push_back(VirtexPacket(eSynchronizationBusWidthSync));
        packets.push_back(VirtexPacket(eSynchronizationBusWidthDetect));
        packets.push_back(dummy);
        packets.push_back(dummy);
        // sync
        packets.push_back(VirtexPacket(eSynchronizationSync));
        packets.push_back(nop);
        // reset CRC command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandRCRC));
        packets.push_back(nop);
        packets.push_back(nop);
        // write the ID code
        packets.push_back(VirtexPacket::makeType1Write(eRegisterIDCODE, 0x00000000));
        // extra for shutdown bitstreams
        if(inBitstreamType == eBitstreamTypePartialShutdown) {
            // configuration options register 0
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCOR0, 
                    makeSubfield(eRegisterCOR0, "DONE_status", "DonePin") |
                    makeSubfield(eRegisterCOR0, "DonePipe", "Yes") |
                    makeSubfield(eRegisterCOR0, "DriveDone", "No") |
                    makeSubfield(eRegisterCOR0, "Capture", "Continuous") |
                    makeSubfield(eRegisterCOR0, "ConfigRate", "[UNKNOWN 0]") |
                    makeSubfield(eRegisterCOR0, "StartupClk", "Cclk") |
                    makeSubfield(eRegisterCOR0, "DONE_cycle", "4") |
                    makeSubfield(eRegisterCOR0, "Match_cycle", "NoWait") |
                    makeSubfield(eRegisterCOR0, "LCK_cycle", "NoWait") |
                    makeSubfield(eRegisterCOR0, "GTS_cycle", "5") |
                    makeSubfield(eRegisterCOR0, "GWE_cycle", "6") |
                0));
            // shutdown command
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandSHUTDOWN));
            packets.push_back(nop);
            // write the CRC value
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCRC, 0x00000000));
            packets.insert(packets.end(), 4, nop);
            // aghigh command
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandAGHIGH));
            packets.push_back(nop);
        }
        // null command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandNULL));
        // return the packet vector
        return packets;
    }

Here is the call graph for this function:

VirtexPacketVector torc::bitstream::Virtex7::generatePartialBitstreamSuffix ( EBitstreamType  inBitstreamType )

virtual

Return a packet vector with the partial bitstream suffix.

Parameters

inBitstreamType

The type of partial bitstream to generate: active or shutdown.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 1141 of file Virtex7.cpp.

                                                                                             {
        //  Packets marked S pertain to shutdown bitstreams only
        //  S   000008ed: TYPE1 WRITE CMD GRESTORE
        //  S   000008f5: NOP x 1
        //      000008f9: TYPE1 WRITE CMD DGHIGH/LFRM
        //      00000901: NOP x 100
        //  S   00000a91: TYPE1 WRITE CMD GRESTORE
        //  S   00000a99: NOP x 1
        //  S   00000a9d: TYPE1 WRITE CMD START
        //  S   00000aa5: NOP x 1
        //      00000aa9: TYPE1 WRITE FAR: 03be0000
        //      00000ab1: TYPE1 WRITE CRC: a658dd48
        //      00000ab9: TYPE1 WRITE CMD DESYNCH
        //      00000ac1: NOP x 16

        // declare the packet vector and define a NOP packet
        typedef VirtexFrame::word_t word_t;
        VirtexPacketVector packets;
        VirtexPacket nop(VirtexPacket::makeHeader(ePacketType1, eOpcodeNOP, 0, 0));
        // extra for shutdown bitstreams
        if(inBitstreamType == eBitstreamTypePartialShutdown) {
            // restore command
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandGRESTORE));
            packets.push_back(nop);
        }
        // last frame command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandLFRM));
        packets.insert(packets.end(), 100, nop);
        // extra for shutdown bitstreams
        if(inBitstreamType == eBitstreamTypePartialShutdown) {
            // restore command
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandGRESTORE));
            packets.push_back(nop);
            // start command
            packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandSTART));
            packets.push_back(nop);
        }
        // frame address register
        packets.push_back(VirtexPacket::makeType1Write(eRegisterFAR, 
            eFarMaskBlockType | eFarMaskRow)); // is this what the configuration controller wants?
        // write the CRC value
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCRC, 0x00000000));
        // desynch command
        packets.push_back(VirtexPacket::makeType1Write(eRegisterCMD, eCommandDESYNCH));
        packets.insert(packets.end(), 16, nop);
        // return the packet vector
        return packets;
    }

Here is the call graph for this function:

uint32_t torc::bitstream::Bitstream::getBitstreamByteLength ( void  ) const

inlineinherited

Return the bitstream packet length in bytes.

The length includes all packet data, but does not include the bitstream header.

Definition at line 340 of file bitstream/Bitstream.hpp.

{ return mBitstreamByteLength; }

VirtexFrameBlocks torc::bitstream::Virtex7::getBitstreamFrames	(	EFarTopBottom	inTopBottom,
		uint32_t	inFrameRow,
		uint32_t	inBitCol,
		uint32_t	inBlockCount = eBlockTypeCount
	)

Returns frames for specified bitstream tile column. inTopBottom The top or bottom half of the device: eFarTop or eFarBottom. inFrameRow The frame or clock region row in the area specified by inTopBottom. inBitCol The bitstream column coordinate (different than the XDL column coordinate). inBlockCount The highest block type requested (8 for Xilinx architectures).

Definition at line 1235 of file Virtex7.cpp.

                                                  {
        return getXdlFrames(inFrameRow + (inTopBottom == eFarBottom ? (mTopRowCount) : 0), 
            mBitColumnToXdlColumn[inBitCol], inBlockCount);
    }

Here is the call graph for this function:

VirtexFrameBlocks torc::bitstream::Virtex7::getBitstreamFrames	(	uint32_t	inBitRow,
		uint32_t	inBitCol,
		uint32_t &	outBeginBit,
		uint32_t &	outEndBit,
		uint32_t	inBlockCount = eBlockTypeCount
	)

Returns frames for specified bitstream tile column. inBitRow The bitstream row coordinate (same as the XDL row coordinate). inBitCol The bitstream column coordinate (different than the XDL column coordinate). outBeginBit The bit index of the beginning of the requested tile. outEndBit The bit index of the end of the requested tile. inBlockCount The highest block type requested (8 for Xilinx architectures).

Definition at line 1241 of file Virtex7.cpp.

                                                                           {
        return getXdlFrames(inBitRow, mBitColumnToXdlColumn[inBitCol], outBeginBit, outEndBit, 
            inBlockCount);
    }

Here is the call graph for this function:

VirtexFrameBlocks torc::bitstream::Virtex7::getBitstreamFrames ( uint32_t  inSerialFrameRow, uint32_t  inBitCol, uint32_t  inBlockCount = eBlockTypeCount  )

protected

Returns frames for queried bitstream coordinates inSerialFrameRow The frame row as indexed starting from top row zero and incrementing toward the top of the device, and then continuing from bottom row zero and incrementing toward the bottom of the device.

Definition at line 1247 of file Virtex7.cpp.

                               {
        return getXdlFrames(inSerialFrameRow, mBitColumnToXdlColumn[inBitCol], inBlockCount);
    }

Here is the call graph for this function:

const string& torc::bitstream::Bitstream::getDesignDate ( void  ) const

inlineinherited

Return the design date.

Definition at line 335 of file bitstream/Bitstream.hpp.

{ return mDesignDate; }

const string& torc::bitstream::Bitstream::getDesignName ( void  ) const

inlineinherited

Return the design name.

Definition at line 331 of file bitstream/Bitstream.hpp.

{ return mDesignName; }

const string& torc::bitstream::Bitstream::getDesignTime ( void  ) const

inlineinherited

Return the design time.

Definition at line 337 of file bitstream/Bitstream.hpp.

{ return mDesignTime; }

const string& torc::bitstream::Bitstream::getDeviceName ( void  ) const

inlineinherited

Return the device name.

Definition at line 333 of file bitstream/Bitstream.hpp.

{ return mDeviceName; }

Here is the caller graph for this function:

VirtexFrameBlocks& torc::bitstream::VirtexBitstream::getFrameBlocks ( void  )

inlineinherited

Return the configuration frame blocks.

Definition at line 139 of file VirtexBitstream.hpp.

{ return mFrameBlocks; }

virtual uint32_t torc::bitstream::Virtex7::getFrameLength ( void  ) const

inlinevirtual

Return the frame length for the current device.

Reimplemented from torc::bitstream::Bitstream.

Definition at line 304 of file Virtex7.hpp.

{ return eFrameLength; }

Here is the caller graph for this function:

virtual uint32_t torc::bitstream::Virtex7::getFrameRowCount ( void  ) const

inlinevirtual

Return the number of frame rows for the current device.

Definition at line 302 of file Virtex7.hpp.

{ return mFrameRowCount; }

Here is the caller graph for this function:

uint32_t torc::bitstream::Bitstream::getHeaderByteLength ( void  ) const

inlineinherited

Return the bitstream header length in bytes.

Definition at line 342 of file bitstream/Bitstream.hpp.

{ return mHeaderByteLength; }

Here is the caller graph for this function:

uint32_t torc::bitstream::Virtex7::getPrimaryXdlColumn	(	uint32_t	inXdlRow,
		uint32_t	inXdlCol
	)

Returns the primary column corresponding to the given tile. If the specified tile falls in an INT_L or INT_R tile, this function returns the index of the corresponding primary XDL column. inXdlCol The XDL column coordinate.

Definition at line 1349 of file Virtex7.cpp.

                                                                              {
        // INT columns "belong" with their corresponding primary column in the bitstream, so if the 
        // caller hands us an INT column, we look for the next primary column;
        // if the caller passes in a primary column, we return it as is
        const ColumnTypeVector& columns = mDeviceInfo.getColumnTypes();
        // look up the column vector base index for this XDL row
        uint32_t columnVectorBase = mXdlRowToFrameRowDesignator[inXdlRow].mColumnVectorBase;
        // determine the bounds for the current column
        uint32_t col = inXdlCol;
        ColumnTypeVector::const_iterator b = columnVectorBase + columns.begin();
        ColumnTypeVector::const_iterator p = columnVectorBase + columns.begin() + col;
        ColumnTypeVector::const_iterator e = columnVectorBase + columns.end();
        // if this is anything other than an INT_L or INT_R column, we return it unchanged
        if(*p != eColumnTypeInt) return inXdlCol;
        // if column to the left is also INT, then this is an INT_R, otherwise it's an INT_L
        if(p > b && *(p-1) == eColumnTypeInt) {
            // this is an INT_R
            while(p < e) {
                col++; p++; if(p == e) break;
                if(*p != eColumnTypeEmpty && *p != eColumnTypeVframe && *p != eColumnTypeCfg 
                    && *p != eColumnTypeClock) return col;
            }
        } else {
            // this is an INT_L
            while(p > b) {
                col--; p--;
                if(*p != eColumnTypeEmpty && *p != eColumnTypeVframe && *p != eColumnTypeCfg 
                    && *p != eColumnTypeClock) return col;
            }
        }
        // we shouldn't get here, but if we do, the best thing is to return the original column
        return inXdlCol;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual uint32_t torc::bitstream::Virtex7::getRowPadFrames ( void  ) const

inlinevirtual

Return the number of pad frames after each row.

Definition at line 306 of file Virtex7.hpp.

{ return eRowPadFrames; }

Here is the caller graph for this function:

VirtexFrameBlocks torc::bitstream::Virtex7::getXdlFrames	(	uint32_t	inXdlRow,
		uint32_t	inXdlCol,
		uint32_t &	outBeginBit,
		uint32_t &	outEndBit,
		uint32_t	inBlockCount = eBlockTypeCount
	)

Returns frames for specified XDL tile coordinates. inXldRow The XDL row coordinate. inXdlCol The XDL column coordinate. outBeginBit The bit index of the beginning of the requested tile. outEndBit The bit index of the end of the requested tile. inBlockCount The highest block type requested (8 for Xilinx architectures).

Definition at line 1252 of file Virtex7.cpp.

                                                                           {

        // look up the frame row designator for this XDL row
        FrameRowDesignator designator = mXdlRowToFrameRowDesignator[inXdlRow];

        // by default we have no bit position information
        outBeginBit = outEndBit = 0;

        // look up the relative XDL row
        uint32_t relativeXdlRow = inXdlRow - designator.mXdlBaseRow;
        //std::cout << "inXdlRow: " << inXdlRow << std::endl;
        //std::cout << "inXdlCol: " << inXdlCol << std::endl;
        //std::cout << "    designator.mTopBottom: " << designator.mTopBottom << std::endl;
        //std::cout << "    designator.mFrameRow: " << designator.mFrameRow << std::endl;
        //std::cout << "    designator.mXdlBaseRow: " << designator.mXdlBaseRow << std::endl;
        //std::cout << "    designator.mColumnVectorBase: " << designator.mColumnVectorBase 
        //  << std::endl;

        // provide bit information for the columns that we know
        uint32_t index = relativeXdlRow;
        uint32_t columnVectorBase = designator.mColumnVectorBase;
        //std::cout << "    relativeXdlRow: " << relativeXdlRow << std::endl;
        //std::cout << "    mDeviceInfo.getColumnTypes()[inXdlCol]: " 
        //  << mDeviceInfo.getColumnTypes()[inXdlCol + columnVectorBase] << std::endl;
        switch(mDeviceInfo.getColumnTypes()[inXdlCol + columnVectorBase]) {
        case eColumnTypeClb:
        case eColumnTypeInt:
            if(index == 0 || index == 26) break; // these tiles have no bits
            index--; // tile 0 has no bits
            outBeginBit = index * 64; // regular tiles are 64 bits long
            outEndBit = outBeginBit + 64;
            if(index > 26) {
                outBeginBit -= 32; // the clock word is 32 bits long
                outEndBit -= 32;   // the clock word is 32 bits long
            }
            break;
        case eColumnTypeDsp:
        case eColumnTypeBram:
            if(index != 5 && index != 10 && index != 15 && index != 20 && index != 25
                && index != 31 && index != 36 && index != 41 && index != 46 && index != 51) break;
            index -= 5;
            outBeginBit = index * 64; // regular tiles are 64 bits long
            outEndBit = outBeginBit + 320;
            if(index > 25) {
                outBeginBit -= 32; // the clock word is 32 bits long
                outEndBit -= 32;   // the clock word is 32 bits long
            }
            break;
        default:
            break;
        }

        // invoke the function that really does the work
        return getXdlFrames(designator.mFrameRow, designator.mColumnVectorBase, inXdlCol);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

VirtexFrameBlocks torc::bitstream::Virtex7::getXdlFrames ( uint32_t  inSerialFrameRow, uint32_t  inColumnVectorBase, uint32_t  inXdlCol, uint32_t  inBlockCount = eBlockTypeCount  )

protected

Returns frames for queried XDL coordinates inSerialFrameRow The frame row as indexed starting from top row zero and incrementing toward the top of the device, and then continuing from bottom row zero and incrementing toward the bottom of the device.

Definition at line 1309 of file Virtex7.cpp.

                                                                               {
        if(inSerialFrameRow > getFrameRowCount()) return VirtexFrameBlocks();

        // index and extract frames
        int32_t xdlColumnIndex[inBlockCount];
        int32_t xdlColumnBound[inBlockCount];
        for(uint32_t i = 0; i < inBlockCount; i++) {
            // column index of given frame index
            xdlColumnIndex[i] = mXdlColumnIndexes[i][inColumnVectorBase + inXdlCol];
            // frame bounds for given column type
            uint32_t col = inColumnVectorBase + inXdlCol;
            xdlColumnBound[i] = mColumnDefs[mDeviceInfo.getColumnTypes()[col]][i];
            //std::cout << "    i: " << i << std::endl;
            //std::cout << "    length: " << mXdlColumnIndexes[i].size() << std::endl;
            //std::cout << "    xdlColumnBound[i]: " << xdlColumnBound[i] << std::endl;
            //std::cout << "    xdlColumnIndex[i]: " << xdlColumnIndex[i] << std::endl;
            //std::cout << "    col: " << col << std::endl;
        }
        // extract the tile frames for the specified FAR 
        VirtexFrameBlocks frameBlocks;
        for(uint32_t i = 0; i < inBlockCount; i++) {
            int startIndex = xdlColumnIndex[i];
            for(int j = 0; j < xdlColumnBound[i]; j++) {
                frameBlocks.mBlock[i].push_back(mFrameBlocks.mBlock[i][startIndex+j]);
                if(!xdlColumnBound[i]) continue;
                int offset = i > 0 ? mXdlColumnIndexes[i-1].back() + 2 : 0;
                std::cout << "Virtex7::getXdlFrames(): pushing mBlock[" << i << "][" 
                    << (startIndex + offset + j) << "]: " 
                    << mFrameIndexToAddress[startIndex + offset + j] << std::endl;
                //std::cout << "    pushing mBlock[" << i << "][" << (startIndex + offset) << "]-[" 
                //  << (startIndex + offset + xdlColumnBound[i] - 1) << "]" << ": " 
                //  << mFrameIndexToAddress[startIndex + offset] << " - " 
                //  << mFrameIndexToAddress[startIndex + offset + xdlColumnBound[i] - 1] 
                //  << std::endl;
            }
        }
        return frameBlocks;
    }

Here is the call graph for this function:

void torc::bitstream::Virtex7::initializeDeviceInfo ( const std::string &  inDeviceName )

virtual

Initialize the Device Information.

Reimplemented from torc::bitstream::Bitstream.

Definition at line 416 of file Virtex7.cpp.

                                                                    {
        using namespace torc::common;
        switch(mDevice) {
            case eXC7A100T: setDeviceInfo(xc7a100t); break;
            case eXC7A200T: setDeviceInfo(xc7a200t); break;
            case eXC7K70T: setDeviceInfo(xc7k70t); break;
            case eXC7K160T: setDeviceInfo(xc7k160t); break;
            case eXC7K325T: setDeviceInfo(xc7k325t); break;
            case eXC7K355T: setDeviceInfo(xc7k355t); break;
            case eXC7K410T: setDeviceInfo(xc7k410t); break;
            case eXC7K420T: setDeviceInfo(xc7k420t); break;
            case eXC7K480T: setDeviceInfo(xc7k480t); break;
            case eXC7V585T: setDeviceInfo(xc7v585t); break;
            case eXC7V2000T: setDeviceInfo(xc7v2000t); break;
            case eXC7VH580T: setDeviceInfo(xc7vh580t); break;
            case eXC7VH870T: setDeviceInfo(xc7vh870t); break;
            case eXC7VX330T: setDeviceInfo(xc7vx330t); break;
            case eXC7VX415T: setDeviceInfo(xc7vx415t); break;
            case eXC7VX485T: setDeviceInfo(xc7vx485t); break;
            case eXC7VX550T: setDeviceInfo(xc7vx550t); break;
            case eXC7VX690T: setDeviceInfo(xc7vx690t); break;
            case eXC7VX980T: setDeviceInfo(xc7vx980t); break;
            case eXC7VX1140T: setDeviceInfo(xc7vx1140t); break;
            case eXC7Z010: setDeviceInfo(xc7z010); break;
            case eXC7Z020: setDeviceInfo(xc7z020); break;
            case eXC7Z030: setDeviceInfo(xc7z030); break;
            case eXC7Z045: setDeviceInfo(xc7z045); break;
            default: break;
        }

        // update the top and bottom bitstream row counts as appropriate for the device
        setRowCounts(inDeviceName);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::bitstream::Virtex7::initializeFrameMaps ( void  )

virtual

Initialize the maps between frame indexes and frame addresses. This is generally useful only for internal purposes.

Reimplemented from torc::bitstream::Bitstream.

Definition at line 710 of file Virtex7.cpp.

                                          {

            bool debug = false;
            setRowCounts(mDeviceName);
            mFrameRowCount = mTopRowCount + mBottomRowCount;
            if(mFrameRowCount == 0) return;
            uint32_t frameCount = 0;

//std::cerr << "row count: " << mDeviceInfo.getRowCount() << ", far row count: " << mFrameRowCount 
//  << std::endl;

            // map XDL tiles to top/bottom halves and frame rows
            mXdlRowToFrameRowDesignator.resize(mDeviceInfo.getRowCount());
            uint32_t xdlRow = 0;
            uint32_t xdlBaseRow = xdlRow;
            uint32_t baseCol = 0;
            uint32_t serialFrame = mTopRowCount - 1;
            baseCol = serialFrame * mDeviceInfo.getColCount();
            for(uint32_t frameRow = mTopRowCount - 1; ; frameRow--) {
                for(int i = 0; i < eClockRegionRows; i++, xdlRow++) {
//std::cout << "mapping XDL row " << xdlRow << " to top frame row " << frameRow << " (serial " 
//  << serialFrame << ")" << " (base " << xdlBaseRow << ") from " << baseCol << std::endl;
                    mXdlRowToFrameRowDesignator[xdlRow] 
                        = FrameRowDesignator(eFarTop, serialFrame, xdlBaseRow, baseCol);
                }
                xdlBaseRow += eClockRegionRows;
                baseCol -= mDeviceInfo.getColCount();
                serialFrame--;
                if(frameRow == 0) break;
            }
            // bottom half rows
            serialFrame = mTopRowCount;
            baseCol = serialFrame * mDeviceInfo.getColCount();
            for(uint32_t frameRow = 0; frameRow < mBottomRowCount; frameRow++) {
                for(int i = 0; i < eClockRegionRows; i++, xdlRow++) {
//std::cout << "mapping XDL row " << xdlRow << " to bottom frame row " << frameRow << " (serial " 
//  << serialFrame << ")" << " (base " << xdlBaseRow << ") from " << baseCol << std::endl;
                    mXdlRowToFrameRowDesignator[xdlRow] 
                        = FrameRowDesignator(eFarBottom, serialFrame, xdlBaseRow, baseCol);
                }
                xdlBaseRow += eClockRegionRows;
                baseCol += mDeviceInfo.getColCount();
                serialFrame++;
            }

            // generate the columns and mappings
            uint32_t frameIndex = 0;
            for(uint32_t i = 0; i < eFarBlockTypeCount; i++) {
                EFarBlockType blockType = EFarBlockType(i);
                uint32_t blockFrameIndexBounds = 0;
                // set first frame index to 0
                uint32_t bitIndex = 0;
                uint32_t xdlIndex = 0;
                mBitColumnIndexes[i].push_back(bitIndex);
                mXdlColumnIndexes[i].push_back(xdlIndex);
                bool blockUsed = false;
                uint32_t baseCol = 0;
                for(uint32_t half = 0; half < 2; half++) {
                    EFarTopBottom topBottom(half == eFarTop ? eFarTop : eFarBottom);
                    uint32_t farRowCount = (topBottom == eFarTop) ? mTopRowCount : mBottomRowCount;
                    for(uint32_t farRow = 0; farRow < farRowCount; farRow++) {
                        // build the columns
                        uint32_t farMajor = 0;
                        typedef torc::common::EncapsulatedInteger<uint16_t> ColumnIndex;
                        uint16_t finalColumn = mDeviceInfo.getColCount() - 1;
                        uint32_t xdlColumnCount = 0;
                        uint32_t bitColumnCount = 0;
                        for(ColumnIndex col; col < mDeviceInfo.getColCount(); col++) {
                            uint32_t realCol = col + baseCol;
                            uint32_t width 
                                = mColumnDefs[mDeviceInfo.getColumnTypes()[col + baseCol]][i];
//std::cerr << "block: " << i << ", xdl col: " << col << " => " << realCol << ": " 
//  << mDeviceInfo.getColumnTypes()[realCol] << std::endl;
                            // allocate the frame maps
                            for(uint32_t farMinor = 0; farMinor < width; farMinor++) {
                                FrameAddress far(EFarTopBottom(topBottom), 
                                    blockType, farRow, farMajor, farMinor);
                                mFrameIndexToAddress[frameIndex] = far;
                                mFrameAddressToIndex[far] = frameIndex;
                                frameIndex++;
                                blockFrameIndexBounds++;
                            }
//if(width) std::cerr << "CALCULATED: " << (topBottom ? "B" : "T") << blockType << "(" << farRow 
//  << "," << farMajor << "." << (width - 1) << "): " 
// << mColumnDefs[mDeviceInfo.getColumnTypes()[col + baseCol]].getName() << std::endl;
                            if(width > 0) {
                                farMajor++;
                                blockUsed = true;
                            }
                            frameCount += width;
                            // indexes for Bitstream Columns, only stores non-empty tile types
                            if(mDeviceInfo.getColumnTypes()[realCol] != eColumnTypeEmpty && 
                                mDeviceInfo.getColumnTypes()[realCol] != eColumnTypeInt) {
                                mBitColumnToXdlColumn[bitColumnCount] = xdlColumnCount;
                                bitColumnCount++;
                                bitIndex += width;
                                mBitColumnIndexes[i].push_back(bitIndex);
                                if(blockUsed && col == finalColumn) {
                                    bitIndex += getRowPadFrames();
                                }
                            }
                            // indexes for XDL Columns
                            xdlIndex += width;
                            mXdlColumnIndexes[i].push_back(xdlIndex);
                            xdlColumnCount++;
                            if(blockUsed && col == finalColumn) {
                                xdlIndex += getRowPadFrames();
                            }
                        }
                        baseCol += mDeviceInfo.getColCount();
                        // account for two pad frames after each frame row
                        if(blockUsed) {
                            frameIndex += getRowPadFrames();
                            blockFrameIndexBounds += getRowPadFrames();
                        }
                        if(debug) std::cout << "Last frame index:   [" << i << ", " << frameIndex 
                            << "]" << std::endl;
                    }
                }
                // stores frame index bounds for each block type
                mBlockFrameIndexBounds[i] = blockFrameIndexBounds;
                if(debug) std::cout << "***Block frame index bounds: " << mBlockFrameIndexBounds[i] 
                    << std::endl;
            }
            // test to check proper indexing
            if(debug) {
                for(uint32_t i = 0; i < eFarBlockTypeCount; i++) {
                    for(uint32_t j = 0; j < mBitColumnIndexes[i].size(); j++) 
                        std::cout << "Bit Value at index: (" << i << ", " << j << ") : "
                            << mBitColumnIndexes[i][j] << std::endl;
                    for(uint32_t k = 0; k < mXdlColumnIndexes[i].size(); k++)
                        std::cout << "Xdl Value at index: (" << i << ", " << k << ") : "
                            << mXdlColumnIndexes[i][k] << std::endl;
                }
            }
    }

Here is the call graph for this function:

void torc::bitstream::Virtex7::initializeFullFrameBlocks

(

void

)

Loads full bitstream frames into block data structure.

Definition at line 1190 of file Virtex7.cpp.

                                                {
        boost::shared_array<uint32_t> frameWords;
        // walk the bitstream and extract all frames
        Virtex7::iterator p = begin();
        Virtex7::iterator e = end();
        while(p < e) {
            const VirtexPacket& packet = *p++;
            if(packet.isType2() && packet.isWrite()) 
                frameWords = packet.getWords();
        }
        uint32_t index = 0;
        for(uint32_t i = 0; i < Bitstream::eBlockTypeCount; i++) {
            // all frames of block type are extracted
            for(uint32_t j = 0; j < mBlockFrameIndexBounds[i]; j++) {
                mFrameBlocks.mBlock[i].push_back(VirtexFrameSet::FrameSharedPtr
                    (new VirtexFrame(getFrameLength(), &frameWords[index])));
                index += getFrameLength();
            }
        }
    }

Here is the call graph for this function:

iterator torc::bitstream::VirtexBitstream::insert ( iterator  position, const value_type &  val  )

inlineinherited

Regular std::vector inserter.

Definition at line 116 of file VirtexBitstream.hpp.

                                                                  {
            return VirtexPacketVector::insert(position, val);
        }

Here is the caller graph for this function:

void torc::bitstream::VirtexBitstream::insert ( iterator  position, size_type  n, const value_type &  val  )

inlineinherited

Regular std::vector inserter.

Definition at line 120 of file VirtexBitstream.hpp.

                                                                           {
            VirtexPacketVector::insert(position, n, val);
        }

template<class InputIterator >

void torc::bitstream::VirtexBitstream::insert ( iterator  position, InputIterator  first, InputIterator  last  )

inlineinherited

Regular std::vector inserter.

Definition at line 124 of file VirtexBitstream.hpp.

                                {
            VirtexPacketVector::insert(position, first, last);
        }

void torc::bitstream::VirtexBitstream::insert ( VirtexPacketVector::iterator  inPosition, const VirtexPacketVector &  inVector  )

inlineinherited

Insert the contents of a packet vector at the specified position.

Definition at line 129 of file VirtexBitstream.hpp.

                                                {
            VirtexPacketVector::insert(inPosition, inVector.begin(), inVector.end());
        }

uint32_t torc::bitstream::Virtex7::makeSubfield ( ERegister  inRegister, const std::string &  inSubfield, const std::string &  inSetting  )

static

Return the masked value for a subfield of the specified register.

Definition at line 361 of file Virtex7.cpp.

                                    {
        const Subfield* subfields;
        switch(inRegister) {
            case eRegisterCOR0: subfields = sCOR0; break;
            case eRegisterCOR1: subfields = sCOR1; break;
            case eRegisterSTAT: subfields = sSTAT; break;
            case eRegisterCTL0: subfields = sCTL0; break;
            case eRegisterCTL1: subfields = sCTL1; break;
            case eRegisterMASK: subfields = sMASK0; break;
            case eRegisterWBSTAR: subfields = sWBSTAR; break;
            case eRegisterTIMER: subfields = sTIMER; break;
            case eRegisterBOOTSTS: subfields = sBOOTSTS; break;
            default: return 0;
        }
        for(uint32_t field = 0; subfields[field].mMask != 0; field++){ 
            const Subfield& subfield = subfields[field]; 
            if(inSubfield != subfield.mBitgenName && inSubfield != subfield.mConfigGuideName)
                continue; 
            const char** ptr = subfield.mValues; 
            for(uint32_t i = 0; *ptr != 0; i++, ptr++){
                if(inSetting == *ptr) return (i << subfield.mShift) & subfield.mMask; 
            }
        } 
        return 0;
    }

Here is the caller graph for this function:

void torc::bitstream::VirtexBitstream::preflightPackets ( void  )

virtualinherited

Preflight the packets.

Reimplemented from torc::bitstream::Bitstream.

Definition at line 493 of file VirtexBitstream.cpp.

                                               {
        // determine which architecture this is
        DeviceDesignator deviceDesignator(getDeviceName());
        DeviceDesignator::EFamily family = deviceDesignator.getFamily();
        switch(family) {
            case DeviceDesignator::eFamilyVirtex: case DeviceDesignator::eFamilyVirtexE:
            case DeviceDesignator::eFamilyVirtex2: case DeviceDesignator::eFamilyVirtex2P:
                updateCrc16(family); break;
            case DeviceDesignator::eFamilyVirtex4: case DeviceDesignator::eFamilyVirtex5: 
            case DeviceDesignator::eFamilyVirtex6: case DeviceDesignator::eFamilyArtix7:
            case DeviceDesignator::eFamilyKintex7: case DeviceDesignator::eFamilyVirtex7: 
            case DeviceDesignator::eFamilyZynq7000: default:
                updateCrc32(family); break;
        }
    }

Here is the call graph for this function:

virtual void torc::bitstream::Bitstream::read ( std::istream &  inStream, bool  inCleanDateAndTime = true  )

inlinevirtualinherited

Read the bitstream header and packets from a stream.

Definition at line 266 of file bitstream/Bitstream.hpp.

                                                                                {
            readHeader(inStream);
            readPackets(inStream);
            if(inCleanDateAndTime) cleanDateAndTime();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void torc::bitstream::Virtex7::readFramePackets ( void  )

inlinevirtual

Read frame data into the frame blocks structure.

Reimplemented from torc::bitstream::VirtexBitstream.

Definition at line 208 of file Virtex7.hpp.

                                            {
            readFramePackets4567<Virtex7>(mBlockFrameIndexBounds, mFrameAddressToIndex, 
                mFrameIndexToAddress);
        }

Here is the caller graph for this function:

template<class ARCH >

void torc::bitstream::VirtexBitstream::readFramePackets4567 ( uint32_t  inBlockFrameIndexBounds[], std::map< typename ARCH::FrameAddress, uint32_t > &  inFrameAddressToIndex, std::map< uint32_t, typename ARCH::FrameAddress > &  inFrameIndexToAddress  )

protectedinherited

Read frame packets in for Virtex4/5/6/7 devices.

Todo:

Definition at line 101 of file VirtexBitstream.cpp.

                                                                            {
        // clean up the template parameters
        typedef typename ARCH::FrameAddress FrameAddress;
        typedef std::map<FrameAddress, uint32_t> FrameAddressToIndex;
        typedef std::map<uint32_t, FrameAddress> FrameIndexToAddress;
        // declare a shared word array
        boost::shared_array<uint32_t> frameWords;
        // precalculate the start indexes of all blocks, and create all possible frames
        uint32_t frameStart[eBlockTypeCount + 1];
        frameStart[0] = 0;
        VirtexFrame frame(ARCH::eFrameLength);
        for(int i = 0; i < eBlockTypeCount; i++) {
            frameStart[i + 1] = frameStart[i] + inBlockFrameIndexBounds[i];
            // clear any existing frames
            mFrameBlocks.mBlock[i].clear();
            // populate the block with the correct number of empty frames
            for(uint32_t j = 0; j < inBlockFrameIndexBounds[i]; j++) {
                mFrameBlocks.mBlock[i].push_back(VirtexFrameSet::FrameSharedPtr
                    (new VirtexFrame(getFrameLength())));
                mFrameBlocks.mBlock[i].back()->setUsed(false);
            }
        }
        // walk the bitstream and extract all frames
        const uint32_t frameLength = getFrameLength();
        uint32_t frameIndex = 0;
        FrameAddress frameAddress;
        typename ARCH::ERegister lastAddress = typename ARCH::ERegister();
        typename ARCH::iterator p = begin();
        typename ARCH::iterator e = end();
        while(p < e) {
            const VirtexPacket& packet = *p++;
            // process FAR write packets
            if(packet.isWrite() && packet.getAddress() == ARCH::eRegisterFAR) {
                // extract the new frame address
                frameAddress = typename ARCH::FrameAddress(packet[1]);
                // convert the frame address to the corresponding frame index
                typename FrameAddressToIndex::iterator ip 
                    = inFrameAddressToIndex.find(frameAddress);
                if(ip != inFrameAddressToIndex.end()) frameIndex = ip->second;
            }
            // process FDRI write packets
            else if(packet.isWrite() 
                && (
                    // this is a Type 2 packet and the prior Type 1 address was FDRI
                    (packet.isType2() && lastAddress == ARCH::eRegisterFDRI)
                ||
                    // this is a non-empty Type 1 packet and its address is FDRI
                    (packet.isType1() && packet.getAddress() == ARCH::eRegisterFDRI 
                    && packet.getWordCount() > 0)
                )) {
                // determine the number of frames in the packet and look up the frame words
                const uint32_t numWords = packet.getWordCount();
                boost::shared_array<uint32_t> frameWords(packet.getWords());
                uint32_t position = 0;
                // iterate over every frame in the packet
                while(position + frameLength <= numWords) {
                    // look up the current block type and the frame index into that block type
                    typename ARCH::EFarBlockType blockType = frameAddress.mBlockType;
                    uint32_t index = frameIndex - frameStart[blockType];
                    mFrameBlocks.mBlock[blockType][index] = VirtexFrameSet::FrameSharedPtr
                        (new VirtexFrame(frameLength, &frameWords[position]));
                    mFrameBlocks.mBlock[blockType][index]->setUsed();
                    position += frameLength;
                    frameIndex++;
                    typename FrameIndexToAddress::iterator ap 
                        = inFrameIndexToAddress.find(frameIndex);
                    if(ap != inFrameIndexToAddress.end()) frameAddress = ap->second;
                    // sanity escape exit (which also breaks out of the higher level loop)
                    if(position > numWords) {
                        std::cerr << "Overflowed expected frame counts for device." << std::endl;
                        break;
                    }
                }
                if(frameIndex != frameStart[frameAddress.mBlockType + 1]) {
                    // if we ended on a pad frame, where the current index has no corresponding 
                    // frame address, we need to advance to the next valid frame address
                    if(inFrameIndexToAddress.find(frameIndex) == inFrameIndexToAddress.end()) 
                        frameIndex++;
                    if(inFrameIndexToAddress.find(frameIndex) == inFrameIndexToAddress.end()) 
                        frameIndex++;
                    // at this point we should again be on a valid frame
                    typename FrameIndexToAddress::iterator ap 
                        = inFrameIndexToAddress.find(frameIndex);
                    if(ap != inFrameIndexToAddress.end()) frameAddress = ap->second;
                    else if(frameIndex == frameStart[frameAddress.mBlockType + 1]) /* at end */;
                    else {
                        std::cerr << "Failed to find the next valid frame address at the end of a "
                            "packet." << std::endl;
                    }
                }
            }
            // remember the last register address for Type 2 packets
            if(packet.isType1()) lastAddress = typename ARCH::ERegister(packet.getAddress());
            // process MFWR write packets
            /// \todo
        }
    }

Here is the call graph for this function:

static bool torc::bitstream::Bitstream::readHeader ( std::istream &  inStream, string &  outDesignName, string &  outDeviceName, string &  outDesignDate, string &  outDesignTime, uint32_t &  outBitstreamLength, uint32_t &  outHeaderLength  )

inlinestaticinherited

Read a bitstream header, and return its fields.

Definition at line 142 of file bitstream/Bitstream.hpp.

                                                                     {
            // assume success unless we find otherwise
            bool success = true;
            // read the magic length
            success &= expect(inStream, uint16_t(0x0009));
            // read the magic bytes
            success &= expect(inStream, uint32_t(0x0ff00ff0));
            success &= expect(inStream, uint32_t(0x0ff00ff0));
            success &= expect(inStream, uint8_t(0x00));
            // read the mysterious 0x0001
            success &= expect(inStream, uint16_t(0x0001));
            // read the 'a' byte
            success &= expect(inStream, uint8_t('a'));
            // read the design name length
            readHeaderString(inStream, outDesignName);
            // read the 'b' byte
            success &= expect(inStream, uint8_t('b'));
            // read the device name length
            readHeaderString(inStream, outDeviceName);
            // read the 'c' byte
            success &= expect(inStream, uint8_t('c'));
            // read the design date length
            readHeaderString(inStream, outDesignDate);
            // read the 'd' byte
            success &= expect(inStream, uint8_t('d'));
            // read the design time length
            readHeaderString(inStream, outDesignTime);
            // read the 'e' byte
            success &= expect(inStream, uint8_t('e'));
            // read the inStream length
            inStream.read((char*) &outBitstreamLength, sizeof(outBitstreamLength));
            outBitstreamLength = ntohl(outBitstreamLength);
            // determine the header length
            outHeaderLength = 34 + outDesignName.length() + outDeviceName.length() 
                + outDesignDate.length() + outDesignTime.length();
            // return the result
            return success;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void torc::bitstream::Bitstream::readHeader ( std::istream &  inStream )

inlinevirtualinherited

Read the bitstream header.

Definition at line 274 of file bitstream/Bitstream.hpp.

                                                      {
            readHeader(inStream, mDesignName, mDeviceName, mDesignDate, mDesignTime, 
                mBitstreamByteLength, mHeaderByteLength);
            setDevice(mDeviceName);
        }

Here is the call graph for this function:

static void torc::bitstream::Bitstream::readHeaderString ( std::istream &  inStream, string &  outString  )

inlinestaticinherited

Read and return a bitstream header string.

Definition at line 124 of file bitstream/Bitstream.hpp.

                                                                              {
            // read the string length
            uint16_t length = 0;
            inStream.read((char*) &length, sizeof(length));
            length = ntohs(length);
            if(length > 0) {
                // create a buffer
                char* buffer = new char[length];
                // read the null-terminated string
                inStream.read(buffer, length);
                // copy the data into the string
                outString.assign(buffer, length - 1);
                delete[] buffer;
            } else {
                outString.clear();
            }
        }

Here is the caller graph for this function:

void torc::bitstream::VirtexBitstream::readPackets ( std::istream &  inStream )

virtualinherited

Read bitstream packets from a stream.

Note

This function should be called after the bitstream header has been read.

Reimplemented from torc::bitstream::Bitstream.

Reimplemented in torc::bitstream::Virtex2.

Definition at line 31 of file VirtexBitstream.cpp.

                                                          {
        uint32_t bitstreamWordLength = mBitstreamByteLength >> 2;
        uint32_t cumulativeWordLength = 0;
        while(cumulativeWordLength < bitstreamWordLength) {
            push_back(VirtexPacket::read(inStream));
            cumulativeWordLength += back().getWordSize();
        }
    }

void torc::bitstream::Bitstream::setDesignDate ( const string &  inDesignDate )

inlineinherited

Set the design date.

Definition at line 327 of file bitstream/Bitstream.hpp.

{ mDesignDate = inDesignDate; }

Here is the caller graph for this function:

void torc::bitstream::Bitstream::setDesignName ( const string &  inDesignName )

inlineinherited

Set the design name.

Definition at line 323 of file bitstream/Bitstream.hpp.

{ mDesignName = inDesignName; }

Here is the caller graph for this function:

void torc::bitstream::Bitstream::setDesignTime ( const string &  inDesignTime )

inlineinherited

Set the design time.

Definition at line 329 of file bitstream/Bitstream.hpp.

{ mDesignTime = inDesignTime; }

Here is the caller graph for this function:

void torc::bitstream::Bitstream::setDevice ( const std::string &  inDeviceName )

inlineinherited

Assign the device enumeration constant for the given device name.

Definition at line 225 of file bitstream/Bitstream.hpp.

                                                      {
            mDevice = torc::common::Devices::getDeviceEnum(inDeviceName);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::bitstream::Bitstream::setDeviceInfo ( const DeviceInfo &  rhs )

inlineinherited

Assign static device information for the current bitstream.

Definition at line 223 of file bitstream/Bitstream.hpp.

{ mDeviceInfo = rhs; }

Here is the caller graph for this function:

void torc::bitstream::Bitstream::setDeviceName ( const string &  inDeviceName )

inlineinherited

Set the device name.

Definition at line 325 of file bitstream/Bitstream.hpp.

{ mDeviceName = inDeviceName; }

Here is the caller graph for this function:

void torc::bitstream::Virtex7::setRowCounts ( const string &  inDeviceName )

protected

Set the number of top and bottom bitstream rows.

Definition at line 670 of file Virtex7.cpp.

                                                         {
        // The division between top and bottom rows can be determined by the locations of the 
        // CLK_HROW_TOP_R and CLK_HROW_BOT_R tiles in the clock column.  The number of clock 
        // regions above and including the CLK_HROW_TOP_R tile determine the number of top rows in 
        // the bitstream.  The number of clock regions below and including the CLK_HROW_BOT_R tile 
        // determine the number of bottom rows in the bitstream.
        using namespace torc::common;
        switch(mDevice) {
            // Artix
            case eXC7A100T: mTopRowCount = 2; mBottomRowCount = 2; break;
            case eXC7A200T: mTopRowCount = 2; mBottomRowCount = 3; break;
            // Kintex
            case eXC7K70T: mTopRowCount = 2; mBottomRowCount = 2; break;
            case eXC7K160T: mTopRowCount = 2; mBottomRowCount = 3; break;
            case eXC7K325T: mTopRowCount = 4; mBottomRowCount = 3; break;
            case eXC7K355T: mTopRowCount = 3; mBottomRowCount = 3; break;
            case eXC7K410T: mTopRowCount = 4; mBottomRowCount = 3; break;
            case eXC7K420T: mTopRowCount = 4; mBottomRowCount = 4; break;
            case eXC7K480T: mTopRowCount = 4; mBottomRowCount = 4; break;
            // Virtex
            case eXC7V585T: mTopRowCount = 5; mBottomRowCount = 4; break;
            case eXC7VX330T: mTopRowCount = 5; mBottomRowCount = 2; break;
            case eXC7VX415T: mTopRowCount = 5; mBottomRowCount = 1; break;
            case eXC7VX485T: mTopRowCount = 5; mBottomRowCount = 2; break;
            case eXC7VX550T: mTopRowCount = 5; mBottomRowCount = 5; break;
            case eXC7VX690T: mTopRowCount = 5; mBottomRowCount = 5; break;
            case eXC7VX980T: mTopRowCount = 4; mBottomRowCount = 5; break;
            // Zynq
            case eXC7Z010: mTopRowCount = 1; mBottomRowCount = 1; break;
            case eXC7Z020: mTopRowCount = 1; mBottomRowCount = 2; break;
            case eXC7Z030: mTopRowCount = 1; mBottomRowCount = 3; break;
            case eXC7Z045: mTopRowCount = 1; mBottomRowCount = 6; break;
            default: 
                std::cerr << "Bitstream row dimensions are undefined for " << mDevice << "." 
                    << std::endl;
                mTopRowCount = 0; mBottomRowCount = 0;
                break;
        }
    }

Here is the caller graph for this function:

virtual void torc::bitstream::Virtex7::splitFrameIndex ( uint32_t  inFrameIndex, uint32_t &  outMajorIndex, uint32_t &  outMinorIndex  )

inlinevirtual

Split the given frame index into the base index of the major frame and the index of the minor frame.

Definition at line 285 of file Virtex7.hpp.

                                     {
            outMinorIndex = mFrameIndexToAddress[inFrameIndex].mMinor;
            outMajorIndex = inFrameIndex - outMinorIndex;
        }

void torc::bitstream::VirtexBitstream::unimplemented ( std::string  inName )

protectedinherited

Reports the named function as not yet implemented in the current architecture.

Definition at line 79 of file VirtexBitstream.cpp.

                                                        {
        std::cerr << inName << " is not yet implemented for this architecture." << std::endl;
    }

void torc::bitstream::VirtexBitstream::updateCrc16 ( torc::common::DeviceDesignator::EFamily  inFamily )

protectedvirtualinherited

Update CRC-16 packets.

Definition at line 509 of file VirtexBitstream.cpp.

                                                                      {
        // set up family-specific variables
        uint32_t crcRegister = 0;
        uint32_t cmdRegister = 0;
        uint32_t fdriRegister = 0;
        uint32_t rcrcCommand = 0;
        uint32_t addressLength = 0;
        bool autoCrc = false;
        switch(inFamily) {
        case DeviceDesignator::eFamilyVirtex: case DeviceDesignator::eFamilyVirtexE: 
            cmdRegister = Virtex::eRegisterCMD; rcrcCommand = Virtex::eCommandRCRC; 
            fdriRegister = Virtex::eRegisterFDRI; crcRegister = Virtex::eRegisterCRC; 
            addressLength = 4; autoCrc = false; 
            break;
        case DeviceDesignator::eFamilyVirtex2: case DeviceDesignator::eFamilyVirtex2P: 
            cmdRegister = Virtex2::eRegisterCMD; rcrcCommand = Virtex2::eCommandRCRC; 
            fdriRegister = Virtex2::eRegisterFDRI; crcRegister = Virtex::eRegisterCRC; 
            addressLength = 5; autoCrc = true; 
            break;
        default:
            std::cerr << "Unsupported architecture in VirtexBitstream::updateCrc16()." << std::endl;
            break;
        }
        // begin CRC calculation
        uint32_t address = 0;
        iterator p = begin();
        iterator e = end();
        // CRC-16-IBM polynomial for Spartan3/6 and Virtex/E/2/2P families
        boost::crc_basic<16> crc16(0x8005, 0, 0, false, true);
        while(p < e) {
            // look up the current packet
            const VirtexPacket& packet = *p++;
            // only process write packets with non-zero payload length
            if(!packet.isWrite()) continue;
            if(packet.isType1()) address = packet.getAddress();
            uint32_t wordCount = packet.getWordCount();
            if(wordCount == 0) continue;
            // CRC register write (this is what compares the expected and supplied CRC values)
            if(address == crcRegister) {
                //printf("Expected CRC16:   %4.4x\n", packet[1]);
                //printf("Calculated CRC16: %4.4x\n", crc16.checksum());
                *(p-1) = VirtexPacket::makeType1Write(crcRegister, crc16.checksum());
                crc16.reset();
            // reset CRC command
            } else if(address == cmdRegister && wordCount >= 1 && packet[1] == rcrcCommand) {
                crc16.reset();
            // process packet contents
            } else {
                uint32_t j;
                uint32_t mask;
                for(uint32_t i = 1; i <= wordCount; i++) {
                    uint32_t word = packet[i];
                    //printf("Address: %4.4x\n", address);
                    //printf("Word: %8.8x\n", word);
                    for(j = 0, mask = 1; j < 32; j++, mask <<= 1) {
                        crc16.process_bit((word & mask) ? 1 : 0);
                    }
                    for(j = 0, mask = 1; j < addressLength; j++, mask <<= 1) {
                        crc16.process_bit((address & mask) ? 1 : 0);
                    }
                }
                // process the Auto CRC on Virtex2 and Virtex2P
                if(autoCrc && address == fdriRegister) {
                    //printf("Expected Auto CRC16:   %4.4x\n", packet[1]);
                    //printf("Calculated Auto CRC16: %4.4x\n", crc16.checksum());
                    *p = VirtexPacket(crc16.checksum()); // current word is FDRI, next is Auto CRC
                    crc16.reset();
                }
            }
        }
    }

Here is the call graph for this function:

void torc::bitstream::VirtexBitstream::updateCrc32 ( torc::common::DeviceDesignator::EFamily  inFamily )

protectedvirtualinherited

Update CRC-32 packets.

Definition at line 581 of file VirtexBitstream.cpp.

                                                                      {
        // set up family-specific variables
        uint32_t crcRegister = 0;
        uint32_t cmdRegister = 0;
        uint32_t rcrcCommand = 0;
        uint32_t addressLength = 5;
        switch(inFamily) {
        case DeviceDesignator::eFamilyVirtex4: 
            cmdRegister = Virtex4::eRegisterCMD; rcrcCommand = Virtex4::eCommandRCRC; 
            crcRegister = Virtex4::eRegisterCRC; 
            break;
        case DeviceDesignator::eFamilyVirtex5: 
            cmdRegister = Virtex5::eRegisterCMD; rcrcCommand = Virtex5::eCommandRCRC; 
            crcRegister = Virtex5::eRegisterCRC; 
            break;
        case DeviceDesignator::eFamilyVirtex6: 
            cmdRegister = Virtex6::eRegisterCMD; rcrcCommand = Virtex6::eCommandRCRC; 
            crcRegister = Virtex6::eRegisterCRC; 
            break;
        case DeviceDesignator::eFamilyArtix7: case DeviceDesignator::eFamilyKintex7: 
        case DeviceDesignator::eFamilyVirtex7: case DeviceDesignator::eFamilyZynq7000: 
            cmdRegister = Virtex7::eRegisterCMD; rcrcCommand = Virtex7::eCommandRCRC; 
            crcRegister = Virtex7::eRegisterCRC; 
            break;
        default:
            std::cerr << "Unsupported architecture in VirtexBitstream::updateCrc32()." << std::endl;
            break;
        }
        // begin CRC calculation
        uint32_t address = 0;
        iterator p = begin();
        iterator e = end();
        // CRC-32C (Castagnoli) polynomial for Virtex4/5/6/7 families
        boost::crc_basic<32> crc32(0x1edc6f41, 0, 0, false, true);
        while(p < e) {
            // look up the current packet
            const VirtexPacket& packet = *p++;
            // only process write packets with non-zero payload length
            if(!packet.isWrite()) continue;
            if(packet.isType1()) address = packet.getAddress();
            uint32_t wordCount = packet.getWordCount();
            if(wordCount == 0) continue;
            // CRC register write (this is what compares the expected and supplied CRC values)
            if(address == crcRegister) {
                //printf("Expected CRC32:   %8.8x\n", packet[1]);
                //printf("Calculated CRC32: %8.8x\n", crc32.checksum());
                *(p-1) = VirtexPacket::makeType1Write(crcRegister, crc32.checksum());
                crc32.reset();
            // reset CRC command
            } else if(address == cmdRegister && wordCount >= 1 && packet[1] == rcrcCommand) {
                crc32.reset();
            // process packet contents
            } else {
                uint32_t j;
                uint32_t mask;
                for(uint32_t i = 1; i <= wordCount; i++) {
                    uint32_t word = packet[i];
                    //printf("Address: %4.4x\n", address);
                    //printf("Word: %8.8x\n", word);
                    for(j = 0, mask = 1; j < 32; j++, mask <<= 1) {
                        crc32.process_bit((word & mask) ? 1 : 0);
                    }
                    for(j = 0, mask = 1; j < addressLength; j++, mask <<= 1) {
                        crc32.process_bit((address & mask) ? 1 : 0);
                    }
                }
            }
        }
    }

Here is the call graph for this function:

void torc::bitstream::VirtexBitstream::updateFramePackets ( EBitstreamType  inBitstreamType = eBitstreamTypeFull, EFrameInclude  inFrameInclusion = eFrameIncludeAllUsedFrames  )

virtualinherited

Update the bitstream frame packets By default this updates the bitstream with full frame data.

Parameters

inBitstreamType	The type of bitstream to generate: full or partial.
inFrameInclusion	The type of frames to include in partial bitstreams: only dirty frames or all frames.

Definition at line 46 of file VirtexBitstream.cpp.

                                        {
        // delete the existing frame packets
        iterator position = deleteFramePackets();
        // insert the new frame packets in place of the old ones
        if(inBitstreamType == eBitstreamTypeFull) {
            insert(position, generateFullBitstreamPackets());
        } else {
            insert(position, generatePartialBitstreamPackets(inFrameInclusion));
        }
    }

Here is the caller graph for this function:

void torc::bitstream::Virtex7::updateFullFrameBlocks

(

void

)

Transfers frame block data into the full bitstream frame packet.

Todo:

If the packet size differs from the frame data size, we need to replace the entire packet.

Definition at line 1211 of file Virtex7.cpp.

                                            {
        /// \todo If the packet size differs from the frame data size, we need to replace the 
        ///     entire packet.
        uint32_t frameLength = getFrameLength();
        typedef boost::shared_array<uint32_t> WordSharedArray;
        // walk the bitstream and find the (full) FDRI write packet
        Virtex7::iterator p = begin();
        Virtex7::iterator e = end();
        while(p < e) {
            const VirtexPacket& packet = *p++;
            if(packet.isType2() && packet.isWrite()) {
                WordSharedArray words = packet.getWords();
                uint32_t* ptr = words.get();
                for(uint32_t block = 0; block < 8; block++) {
                    for(uint32_t frame = 0; frame < mBlockFrameIndexBounds[block]; frame++) {
                        const VirtexFrameBlocks::word_t* words 
                            = mFrameBlocks.mBlock[block][frame]->getWords();
                        for(uint32_t index = 0; index < frameLength; index++) *ptr++ = *words++;
                    }
                }
            }
        }
    }

Here is the call graph for this function:

void torc::bitstream::VirtexBitstream::updatePacketLength ( void  )

virtualinherited

Update the header packet length.

Reimplemented from torc::bitstream::Bitstream.

Definition at line 651 of file VirtexBitstream.cpp.

                                                 {
        uint32_t totalWordCount = 0;
        iterator p = begin();
        iterator e = end();
        while(p < e) totalWordCount += (p++)->getWordSize();
        mBitstreamByteLength = totalWordCount << 2;
    }

void torc::bitstream::Bitstream::write ( std::ostream &  inStream, uint8_t  inVal  )

inlineinherited

Write a uint8_t to the stream.

Definition at line 67 of file bitstream/Bitstream.hpp.

                                                        {
            uint8_t actual = inVal;
            inStream.write((char*) &actual, sizeof(actual));
        }

Here is the caller graph for this function:

void torc::bitstream::Bitstream::write ( std::ostream &  inStream, uint16_t  inVal  )

inlineinherited

Write a uint16_t to the stream.

Definition at line 72 of file bitstream/Bitstream.hpp.

                                                         {
            uint16_t actual = htons(inVal);
            inStream.write((char*) &actual, sizeof(actual));
        }

void torc::bitstream::Bitstream::write ( std::ostream &  inStream, uint32_t  inVal  )

inlineinherited

Write a uint32_t to the stream.

Definition at line 77 of file bitstream/Bitstream.hpp.

                                                         {
            uint32_t actual = htonl(inVal);
            inStream.write((char*) &actual, sizeof(actual));
        }

virtual void torc::bitstream::Bitstream::write ( std::ostream &  inStream )

inlinevirtualinherited

Write the bitstream header and packets to a stream.

Definition at line 280 of file bitstream/Bitstream.hpp.

                                                 {
            preflightPackets();
            updatePacketLength();
            writeHeader(inStream);
            writePackets(inStream);
        }

Here is the call graph for this function:

void torc::bitstream::Bitstream::writeDeviceInfo ( std::ostream &  inStream, const std::string &  inDeviceName  )

virtualinherited

Output static device information to a stream.

This is used to generate the static column maps for bitstream frame mapping.

Definition at line 74 of file Bitstream.cpp.

                                       {
        // write the device column composition
        inStream << "\t// " << inDeviceName << " static device information." << std::endl;
        inStream << "\tboost::uint32_t " << inDeviceName << "Columns[] = { ";
        ColumnTypeVector::const_iterator p = mDeviceInfo.getColumnTypes().begin();
        ColumnTypeVector::const_iterator e = mDeviceInfo.getColumnTypes().end();
        while(p < e) inStream << mColumnDefs[*p++].getName() << ", ";
        inStream << "END };" << std::endl;
        // instantiate the device information
        inStream << "\tDeviceInfo " << inDeviceName << "(" << mDeviceInfo.getTileCount() << ", " 
            << mDeviceInfo.getRowCount() << ", " << mDeviceInfo.getColCount() << ", " 
            << inDeviceName << "Columns);" << std::endl;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void torc::bitstream::Bitstream::writeHeader ( std::ostream &  inStream )

inlinevirtualinherited

Write the bitstream header to the stream.

Definition at line 293 of file bitstream/Bitstream.hpp.

                                                       {
            // write the magic length
            write(inStream, uint16_t(0x0009));
            // write the magic bytes with null termination
            write(inStream, uint32_t(0x0ff00ff0));
            write(inStream, uint32_t(0x0ff00ff0));
            write(inStream, uint8_t(0x00));
            // write the mysterious 0x0001
            write(inStream, uint16_t(0x0001));
            // write the 'a' byte and the design name
            write(inStream, uint8_t('a'));
            writeHeaderString(inStream, mDesignName);
            // write the 'b' byte and the device name
            write(inStream, uint8_t('b'));
            writeHeaderString(inStream, mDeviceName);
            // write the 'c' byte and the design date
            write(inStream, uint8_t('c'));
            writeHeaderString(inStream, mDesignDate);
            // write the 'd' byte and the design time
            write(inStream, uint8_t('d'));
            writeHeaderString(inStream, mDesignTime);
            // write the 'e' byte and the design name
            write(inStream, uint8_t('e'));
            write(inStream, uint32_t(mBitstreamByteLength));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::bitstream::Bitstream::writeHeaderString ( std::ostream &  inStream, const string &  inString  )

inlineinherited

Write a Xilinx-style header string to the stream.

Definition at line 82 of file bitstream/Bitstream.hpp.

                                                                             {
            // write the string length
            uint16_t length = inString.length() + 1;
            write(inStream, uint16_t(length));
            inStream.write(inString.c_str(), length);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::bitstream::VirtexBitstream::writePackets ( std::ostream &  inStream )

virtualinherited

Write bitstream packets to a stream.

Reimplemented from torc::bitstream::Bitstream.

Definition at line 40 of file VirtexBitstream.cpp.

                                                           {
        const_iterator p = begin();
        const_iterator e = end();
        while(p < e) p++->write(inStream);
    }

void torc::bitstream::Bitstream::writeSubfieldSettings ( std::ostream &  inStream, uint32_t  inWord, const Subfield *  inSubfields  )

staticinherited

Insert 32 bit subfield settings into an output stream.

Definition at line 26 of file Bitstream.cpp.

                                     {
        // count the subfields
        int subfieldCount = 0;
        while(inSubfields[subfieldCount].mMask) subfieldCount++;
        // generate the output
        inStream << " (";
        for(int index = subfieldCount; index > 0; index--) {
            uint32_t field = index - 1;
            const Subfield& subfield = inSubfields[field];
            uint32_t value = (inWord & subfield.mMask) >> subfield.mShift;
            inStream << (*subfield.mBitgenName == 0 ? subfield.mConfigGuideName 
                : subfield.mBitgenName) << ":";
            const char** ptr = subfield.mValues;
            for(uint32_t i = 0; ; i++) {
                if(*ptr == 0) { inStream << "[UNKNOWN " << i << "]"; break; }
                if(value == i) { inStream << *ptr; break; }
                ptr++;
            }
            if(index > 1) inStream << ", ";
        }
        inStream << ")";
    }

Here is the caller graph for this function:

void torc::bitstream::Bitstream::writeSubfieldSettings ( std::ostream &  inStream, uint16_t  inWord, const Subfield *  inSubfields  )

staticinherited

Insert 16 bit subfield settings into an output stream.

Definition at line 50 of file Bitstream.cpp.

                                     {
        // count the subfields
        int subfieldCount = 0;
        while(inSubfields[subfieldCount].mMask) subfieldCount++;
        // generate the output
        inStream << " (";
        for(int index = subfieldCount; index > 0; index--) {
            uint16_t field = index - 1;
            const Subfield& subfield = inSubfields[field];
            uint16_t value = (inWord & subfield.mMask) >> subfield.mShift;
            inStream << (*subfield.mBitgenName == 0 ? subfield.mConfigGuideName 
                : subfield.mBitgenName) << ":";
            const char** ptr = subfield.mValues;
            for(uint16_t i = 0; ; i++) {
                if(*ptr == 0) { inStream << "[UNKNOWN " << i << "]"; break; }
                if(value == i) { inStream << *ptr; break; }
                ptr++;
            }
            if(index > 1) inStream << ", ";
        }
        inStream << ")";
    }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const Virtex7 &  rhs  )

friend

Insert the bitstream header into and output stream.

Definition at line 1139 of file bitstream/OutputStreamHelpers.cpp.

                                                                {
        // insert the bitstream header
        os << static_cast<const Bitstream>(rhs) << std::endl;
        uint32_t cumulativeWordLength = 0;

        // iterate over the packets
        Virtex7::ERegister address = Virtex7::ERegister();
        VirtexPacketVector::const_iterator p = rhs.begin();
        VirtexPacketVector::const_iterator e = rhs.end();
        bool synchronized = false;
        bool newColumn = false;
        bool newRow = false;
        bool newTop = false;
        bool newBlock = false;
        uint32_t oldColumnValue = 0;
        uint32_t oldRowValue = 0;
        uint32_t oldTopValue = 0;
        uint32_t oldBlockValue = 0;
        uint32_t currentColumnValue = 0;
        uint32_t currentRowValue = 0;
        uint32_t currentTopValue = 0;
        uint32_t currentBlockValue = 0;
        while(p < e) {

            // insert the byte address
            os << "    " << Hex32(rhs.getHeaderByteLength() + (cumulativeWordLength << 2)) << ": ";
            // look up the packet
            const VirtexPacket& packet = *p++;
            cumulativeWordLength += packet.getWordSize();

            // catch bus sync words
            if(!synchronized) {
                if(packet.isBusWidthSyncWord()) {
                    os << "BUS WIDTH SYNC" << std::endl;
                    continue;
                } else if(packet.isBusWidthDetectWord()) {
                    os << "BUS WIDTH DETECT" << std::endl;
                    continue;
                }
            }

            // handle dummy words
            if(packet.isDummyWord()) {
                os << "DUMMY" << std::endl;

            // handle sync words
            } else if(packet.isSyncWord()) {
                os << "SYNC" << std::endl;

            // handle reserved packets
            } else if(packet.isReserved()) {
                os << Virtex7::sOpcodeName[packet.getOpcode()] << std::endl;

            // handle NOP packets
            } else if(packet.isNop()) {
                int nops = 1;
                while(p < e && p->isNop()) { nops++; p++; }
                cumulativeWordLength += nops - 1;
                os << "NOP x " << nops << std::endl;

            // handle regular type 1 or type 2 packets
            } else {

                // look up the packet details
                Virtex7::EPacketType type = packet.getType();
                Virtex7::EOpcode opcode = packet.getOpcode();
                uint32_t wordCount = packet.getWordCount();
                const uint32_t word = packet[1];
                // account for the packet type
                os << Virtex7::sPacketTypeName[type];
                switch(type) {
                case Virtex7::ePacketType1: 
                    address = Virtex7::ERegister(packet.getAddress());
                    break;
                case Virtex7::ePacketType2: 
                    break;
                default: 
                    os << std::endl;
                    continue;
                }

                // handle read packets
                if(opcode == packet.isRead()) {
                    os << " READ " << Virtex7::sRegisterName[address];

                // handle write packets
                } else if(opcode == Virtex7::eOpcodeWrite) {
                    os << " WRITE " << Virtex7::sRegisterName[address];
                    // process according to register address
                    switch(address) {
                    case Virtex7::eRegisterFDRI:
                        os << ": " << Hex32(wordCount) << " words";
                        break;
                    case Virtex7::eRegisterCMD: 
                        os << " " << Virtex7::sCommandName[word];
                        break;
                    case Virtex7::eRegisterCOR0:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sCOR0);
                        break;
                    case Virtex7::eRegisterCOR1:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sCOR1);
                        break;
                    case Virtex7::eRegisterSTAT:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sSTAT);
                        break;
                    case Virtex7::eRegisterCTL0:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sCTL0);
                        break;
                    case Virtex7::eRegisterCTL1:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sCTL1);
                        break;
                    case Virtex7::eRegisterMASK:
                        os << ": " << Hex32(word);
                        // we need to snoop the next packet, because the documented mask subfields 
                        // apply to CTL0 only, and not to CTL1 which is completely undefined
                        if(p < e) {
                            const VirtexPacket& nextPacket = *p;
                            if(nextPacket.isType1() && nextPacket.isWrite() 
                                && nextPacket.getAddress() == Virtex7::eRegisterCTL1) {
                                os << " ()";
                                break;
                            }
                        }
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sMASK0);
                        break;
                    case Virtex7::eRegisterWBSTAR:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sWBSTAR);
                        break;
                    case Virtex7::eRegisterTIMER:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sTIMER);
                        break;
                    case Virtex7::eRegisterBOOTSTS:
                        os << ": " << Hex32(word);
                        Virtex7::writeSubfieldSettings(os, (uint32_t) word, Virtex7::sBOOTSTS);
                        break;
                    // Added to make frame mapping debug easier
                    case Virtex7::eRegisterLOUT:
                        oldColumnValue = currentColumnValue;
                        oldRowValue = currentRowValue;
                        oldTopValue = currentTopValue;
                        oldBlockValue = currentBlockValue;
                        currentColumnValue = (word & Virtex7::eFarMaskMajor);
                        currentRowValue = (word & Virtex7::eFarMaskRow);
                        currentTopValue = (word & Virtex7::eFarMaskTopBottom);
                        currentBlockValue = (word & Virtex7::eFarMaskBlockType);
                        newColumn = (currentColumnValue != oldColumnValue);
                        newRow = (currentRowValue != oldRowValue);
                        newTop = (currentTopValue != oldTopValue);
                        newBlock = (currentBlockValue != oldBlockValue);
                        os << ": " << Hex32(word);
                        if(newColumn) std::cout << "\t\t\t!!!New Column!!!";
                        if(newRow) std::cout << "\t\t\t$$$New Row$$$";
                        if(newTop) std::cout << "\t\t\t&&&New Top&&&";
                        if(newBlock) std::cout << "\t\t\t\t\t***New Block***" << Hex32(currentBlockValue);
                        break;
                    default:
                        // output the register contents
                        os << ": " << Hex32(word);
                        break;
                    }

                    os << std::endl;
                }

            }

        }

        // return the stream reference
        return os;
    }

void torc::bitstream::bitstream::testVirtex7Device ( const std::string &  inDeviceName, const boost::filesystem::path &  inWorkingPath  )

friend

friend class torc::bitstream::bitstream::Virtex7FarUnitTest

friend

Definition at line 42 of file Virtex7.hpp.

friend class torc::bitstream::bitstream::Virtex7UnitTest

friend

Definition at line 41 of file Virtex7.hpp.

friend class torc::bitstream::bitstream::Zynq7000DebugUnitTest

friend

Definition at line 43 of file Virtex7.hpp.

Field Documentation

IndexVector torc::bitstream::Virtex7::mBitColumnIndexes[Virtex7::eFarBlockTypeCount]

protected

Vector to store frame indexes of XDL columns.

Definition at line 417 of file Virtex7.hpp.

BitColumnToXdlColumn torc::bitstream::Virtex7::mBitColumnToXdlColumn

protected

Map of bitstream column indexes to XDL column indexes.

Definition at line 423 of file Virtex7.hpp.

uint32_t torc::bitstream::Bitstream::mBitstreamByteLength

inherited

Bitstream packet length in bytes.

This is the length in bytes of all the bitstream packets, without the bitstream header.

Definition at line 242 of file bitstream/Bitstream.hpp.

FrameSet<VirtexFrame > torc::bitstream::FrameBlocks< VirtexFrame >::mBlock[Bitstream::eBlockTypeCount]

inherited

FrameSets for each of the eight block types.

Definition at line 88 of file FrameSet.hpp.

uint32_t torc::bitstream::Virtex7::mBlockFrameIndexBounds[Virtex7::eFarBlockTypeCount]

protected

Array to hold frame index boundaries for blocks.

Definition at line 421 of file Virtex7.hpp.

uint32_t torc::bitstream::Virtex7::mBottomRowCount

protected

The number of bottom bitstream rows.

Definition at line 142 of file Virtex7.hpp.

ColumnDefVector torc::bitstream::Bitstream::mColumnDefs

inherited

Column type widths.

Definition at line 249 of file bitstream/Bitstream.hpp.

string torc::bitstream::Bitstream::mDesignDate

inherited

Header design date.

Definition at line 236 of file bitstream/Bitstream.hpp.

string torc::bitstream::Bitstream::mDesignName

inherited

Header design name.

Definition at line 232 of file bitstream/Bitstream.hpp.

string torc::bitstream::Bitstream::mDesignTime

inherited

Header design time.

Definition at line 238 of file bitstream/Bitstream.hpp.

EDevice torc::bitstream::Bitstream::mDevice

inherited

Bitstream device enumeration.

Definition at line 230 of file bitstream/Bitstream.hpp.

DeviceInfo torc::bitstream::Bitstream::mDeviceInfo

inherited

Device information.

Definition at line 257 of file bitstream/Bitstream.hpp.

string torc::bitstream::Bitstream::mDeviceName

inherited

Header device name.

Definition at line 234 of file bitstream/Bitstream.hpp.

FrameAddressToIndex torc::bitstream::Virtex7::mFrameAddressToIndex

protected

Map of frame addresses to frame indexes.

Definition at line 415 of file Virtex7.hpp.

VirtexFrameBlocks torc::bitstream::VirtexBitstream::mFrameBlocks

protectedinherited

Input Frame blocks.

Definition at line 65 of file VirtexBitstream.hpp.

FrameIndexToAddress torc::bitstream::Virtex7::mFrameIndexToAddress

protected

Map of frame indexes to frame addresses.

Definition at line 413 of file Virtex7.hpp.

uint32_t torc::bitstream::Virtex7::mFrameRowCount

protected

Number of frame rows.

Definition at line 425 of file Virtex7.hpp.

uint32_t torc::bitstream::Bitstream::mHeaderByteLength

inherited

Header length in bytes.

This is the length of the header itself, as opposed to mBitstreamByteLength, which is the length of bitstream reported by the header.

Definition at line 246 of file bitstream/Bitstream.hpp.

TileTypeIndexToColumnType torc::bitstream::Bitstream::mTileTypeIndexToColumnType

inherited

Definition at line 255 of file bitstream/Bitstream.hpp.

TileTypeNameToColumnType torc::bitstream::Bitstream::mTileTypeNameToColumnType

inherited

Definition at line 252 of file bitstream/Bitstream.hpp.

uint32_t torc::bitstream::Virtex7::mTopRowCount

protected

The number of top bitstream rows.

Definition at line 140 of file Virtex7.hpp.

IndexVector torc::bitstream::Virtex7::mXdlColumnIndexes[Virtex7::eFarBlockTypeCount]

protected

Vector to store frame indexes of Bitstream columns.

Definition at line 419 of file Virtex7.hpp.

FrameRowDesignatorVector torc::bitstream::Virtex7::mXdlRowToFrameRowDesignator

protected

Vector of FrameRowDesignator entries for each XDL row.

Definition at line 427 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sBOOTSTS

staticprotected

Boot History Status Register (BOOTSTS) subfields.

See Also

BOOTSTS Register Description: UG470, v1.1, March 28, 2011, Table 5-35.

Definition at line 138 of file Virtex7.hpp.

const char * torc::bitstream::Virtex7::sCommandName

staticprotected

Initial value:

= {
        "NULL", "WCFG", "MFW", "DGHIGH/LFRM", "RCFG", "START", "RCAP", "RCRC", 
        "AGHIGH", "SWITCH", "GRESTORE", "SHUTDOWN", "GCAPTURE", "DESYNCH", "Reserved", 
        "IPROG", "CRCC", "LTIMER"
    }

Configuration Command names.

Definition at line 120 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sCOR0

staticprotected

Configurations Options Register 0 (COR) subfields.

See Also

Configurations Options Register 0 (COR0): UG470, v1.1, March 28, 2011, Table 5-27.

Definition at line 122 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sCOR1

staticprotected

Initial value:

= {
        {0x00000003, 0, "BPI_page_size", "BPI_PAGE_SIZE", 0,
            
            
            VALUES{"1", "4", "8", "Reserved", 0}},
        {0x0000000C, 2, "BPI_1st_read_cycle", "BPI_1ST_READ_CYCLES", 0,
            
            
            VALUES{"1", "2", "3", "4", 0}},
            
        {0x00000100,  8, "ContinuousReadbackCRC", "RBCRC_EN", 0, 
            
            
            VALUES{"Enabled", "disabled", 0}},
            
        {0x00000200,  9, "InitAsCRCErrorPin", "RBCRC_NO_PIN", 0,
            
            
            VALUES{"Disabled", "Enabled", 0}},
        {0x00018000, 15, "ActionReadbackCRC", "RBCRC_ACTION", 0,
            
            
            VALUES{"Continue", "Halt", "CorrectAndHalt", "CorrectAndContinue", 0}},
        {0x00020000, 17, "PersistDeassertAtDesynch", "PERSIST_DEASSERT_AT_DESYNCH", 0,
            
            
            VALUES{"Disabled", "Enabled", 0}},
        {0, 0, 0, 0, 0, 0}
    }

Configurations Options Register 1 (COR) subfields.

See Also

Configurations Options Register 1 (COR1): UG470 v1.1, March 28, 2011, Table 5-29 .

Definition at line 124 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sCTL0

staticprotected

Control Register 0 (CTL) subfields.

See Also

Control Register 0 (CTL0): UG470, v1.1, March 28, 2011, Table 5-23

Definition at line 128 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sCTL1

staticprotected

Initial value:

= {
        {0, 0, 0, 0, 0, 0}
    }

Control Register 1 (CTL) subfields.

See Also

Control Register 1 (CTL1): UG470, v1.1, March 28, 2011, Table 5-36

Definition at line 130 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sMASK0

staticprotected

Initial value:

= {
        {0x00000001,  0, "GTS_USER_B", "GTS_USER_B", 0, VALUES{"Protected", "Writable", 0}},
        {0x00000008,  3, "Persist", "PERSIST", 0,  VALUES{"Protected", "Writable", 0}},
        {0x00000030,  4, "Security", "SBITS", 0, 
            VALUES{"Protected", "[UNKNOWN 1]", "[UNKNOWN 2]", "Writable", 0}},
        {0x00000040,  6, "Encrypt", "DEC", 0,  VALUES{"Protected", "Writable", 0}},
        {0x00000080,  7, "FARSRC", "FARSRC", 0,  VALUES{"Protected", "Writable", 0}},
        {0x00000100,  8, "GLUTMASK", "GLUTMASK", 0,  VALUES{"Protected", "Writable", 0}},
        {0x00001000, 12, "OverTempPowerDown", "OverTempPowerDown", 0, 
            VALUES{"Protected", "Writable", 0}},
        {0x40000000, 30, "ICAP_sel", "ICAP_SEL", 0, VALUES{"Protected", "Writable", 0}},
        {0x80000000, 31, "EFUSE_key", "EFUSE_KEY", 0, VALUES{"Protected", "Writable", 0}},
        {0, 0, 0, 0, 0, 0}
    }

Control Mask Register (MASK) subfields.

See Also

Control Register 0 (CTL0): UG470, v1.1, March 28, 2011, Table 5-22.

Definition at line 132 of file Virtex7.hpp.

const char * torc::bitstream::Virtex7::sOpcodeName

staticprotected

Initial value:

= {
        "NOP", "READ", "WRITE", "RESERVED"
    }

Packet Opcode names.

Definition at line 116 of file Virtex7.hpp.

const char * torc::bitstream::Virtex7::sPacketTypeName

staticprotected

Initial value:

= {
        "[UNKNOWN TYPE 0]", "TYPE1", "TYPE2", "[UNKNOWN TYPE 3]", "[UNKNOWN TYPE 4]", 
        "[UNKNOWN TYPE 5]", "[UNKNOWN TYPE 6]", "[UNKNOWN TYPE 7]"
    }

Configuration controller registers.

Packet Type names.

Definition at line 114 of file Virtex7.hpp.

const char * torc::bitstream::Virtex7::sRegisterName

staticprotected

Initial value:

= {
        "CRC", "FAR", "FDRI", "FDRO", "CMD", "CTL0", "MASK", "STAT", "LOUT", "COR0", 
        "MFWR", "CBC", "IDCODE", "AXSS", "COR1", "[UNKNOWN REG 15]","WBSTAR", "TIMER",
        "[UNKNOWN REG 18]","[UNKNOWN REG 19]", "[UNKNOWN REG 20]", "[UNKNOWN REG 21]", 
        "BOOTSTS", "[UNKNOWN REG 23]", "CTL1"
    }

Configuration Register names.

Definition at line 118 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sSTAT

staticprotected

Status Register (STAT) subfields.

See Also

Status Register Description: UG470, v1.1, March 28, 2011, Table 5-25.

Definition at line 126 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sTIMER

staticprotected

Initial value:

= {
        {0x40000000, 30, "TimerForConfig", "TIMER_CFG_MON", 0,
            
            VALUES{"Disabled", "Enabled", 0}},
        {0x80000000, 31, "TimerForUser", "TIMER_USR_MON", 0,
            
            VALUES{"Disabled", "Enabled", 0}},
        {0, 0, 0, 0, 0, 0}
    }

Watchdog Timer Register (TIMER) subfields.

See Also

TIMER Register Description: UG470, v1.1, March 28, 2011, Table 5-33.

Definition at line 136 of file Virtex7.hpp.

const Bitstream::Subfield torc::bitstream::Virtex7::sWBSTAR

staticprotected

Initial value:

= {
        {0x40000000, 30, "NextRevisionSelect", "RS[1:0]", 0,
            
            VALUES{"00", "01", "10", "11", 0}},
        {0x20000000, 29, "RevisionSelectTristate", "RS_TS_B", 0,
            
            VALUES{"Disabled", "Enabled", 0}},
        {0, 0, 0, 0, 0, 0}
    }

Warm Boot Start Address Register (WBSTAR) subfields.

See Also

WBSTAR Register Descrption: UG470, v1.1, March 28, 2011, Table 5-31.

Definition at line 134 of file Virtex7.hpp.

---

The documentation for this class was generated from the following files:

• Virtex7.hpp
• Virtex7.cpp