XilinxSeries7 Class Reference

#include "XilinxSeries7.h"

Inheritance diagram for XilinxSeries7:

Collaboration diagram for XilinxSeries7:

Public Member Functions
void	assembler (std::string, std::string)
void	assemblerAsmTo (std::ifstream &, std::ofstream &)
void	assemblerAsmToBin (std::ifstream &, std::ofstream &)
void	assemblerAsmToBit (std::ifstream &, std::ofstream &)
void	assemblerParseHeader (std::ifstream &)
void	blank (std::string)
void	change (std::string)
void	deviceHelp ()
void	disassemblerBinToAsm (std::string, std::ifstream &, std::ofstream &)
void	disassemblerBitToAsm (std::ifstream &, std::ofstream &)
void	disassemblerToAsm (std::ifstream &, std::ofstream &)
void	disassemblerWriteHeader (std::ofstream &)
void	ensureInitializedBitstreamArrays () override
int	getDeviceByIDCODE (int) override
int	getDeviceByIDCODEorThrow (int) override
int	getDeviceByName (std::string) override
int	getDeviceByNameOrThrow (std::string) override
std::string	getFrameType (int, int, int) override
void	initFabric ()
void	initializeResourceStringParameters () override
void	merge (XilinxSeries7 *, std::string, Rect2D, Coord2D)
void	outputBitstreamEmptySLRHeaderSequence (std::ofstream &, int, bool, Endianness) override
void	outputBitstreamEmptySLRWrapUpSequence (std::ofstream &, int, bool, Endianness) override
void	outputBitstreamGlobalFooterSequence (std::ofstream &, bool, Endianness) override
void	outputBitstreamGlobalHeaderSequence (std::ofstream &, bool, Endianness) override
	Written by outputBitstreamSLRHeaderAfterBitstreamSequence(), outputBitstreamEmptySLRHeaderSequence() and used by outputBitstreamSLRWrapUpSequence(), outputBitstreamEmptySLRWrapUpSequence() More...
void	outputBitstreamSLRFooterBitstreamSequence (std::ofstream &, int, bool, Endianness) override
void	outputBitstreamSLRHeaderAfterBitstreamSequence (std::ofstream &, int, bool, Endianness) override
void	outputBitstreamSLRHeaderBitstreamSequence (std::ofstream &, int, bool, Endianness) override
void	outputBitstreamSLRWrapUpSequence (std::ofstream &, int, bool, Endianness) override
void	readBitstream (std::string)
void	setDevice (int, std::string="") override
void	setDeviceByIDCODEOrThrow (int) override
void	setDeviceByNameOrThrow (std::string) override
void	setDeviceByPartNameOrThrow () override
void	test (bool, bool, uint32_t)
void	writeBitstream (std::string, std::string, Rect2D)
	XilinxSeries7 ()
virtual	~XilinxSeries7 ()
Public Member Functions inherited from CommonDevice2D
	CommonDevice2D ()
void	region (std::string, Rect2D)
virtual	~CommonDevice2D ()
Public Member Functions inherited from CommonDevice
	CommonDevice ()
void	log (std::string message)
void	printMessage (std::string message)
void	warn (std::string message)
virtual	~CommonDevice ()
Public Member Functions inherited from XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >
	XilinxConfigurationAccessPort ()
virtual	~XilinxConfigurationAccessPort ()

Public Attributes
std::streamoff	slrMagicInstrLocation [5]
Public Attributes inherited from CommonDevice2D
std::vector< Rect2D >	regionSelection
Public Attributes inherited from CommonDevice
int	enableLog
int	enableWarn
std::string	instanceName
Public Attributes inherited from XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >
uint32_t *	bitstreamBegin
uint32_t *	bitstreamBRAM [MAX_ROWS][MAX_BRAM_COLS]
uint32_t *	bitstreamCLB [MAX_ROWS][MAX_COLS]
uint32_t *	bitstreamEnd
bool	bitstreamHasValidData
std::string	designName
std::string	fileDate
std::string	fileTime
int	fromRow
std::streamoff	headerLocationOfRemainingFileLength
	gets set by outputBITheader() and gets used by outputBITheaderLengthField(). More...
uint32_t	IDCODE
std::string	initializedBitstreamParamsShortPartName
	the partName of currently initialized resource string parameters More...
std::string	initializedBitstreamShortPartName
	The partName of currently initialized bitstream buffers. More...
std::string	initializedResourceStringShortPartName
	the partName of currently initialized resource string parameters More...
Endianness	loadedBitstreamEndianness
	The endianess of the currently loaded bitstream. More...
bool	LUT_isFrameUnusedForResourceLetter [256]
int	LUT_numberOfFramesForResourceLetter [256]
std::string	LUT_typeOfFrameForResourceLetter [256]
int	maxNumberOfBRAMCols
int	maxNumberOfCols
int	numberOfBRAMCols [MAX_ROWS]
int	numberOfBRAMsBeforeCol [MAX_ROWS][MAX_COLS]
int	numberOfCols [MAX_ROWS]
int	numberOfFramesBeforeCol [MAX_ROWS][MAX_COLS]
int	numberOfFramesPerRow [MAX_ROWS]
int	numberOfRows
int	numberOfSLRs
int	numberOfWordsPerRow [MAX_ROWS]
std::string	partName
char	resourceString [MAX_ROWS][MAX_COLS]
int	rowsInBottomHalf
int	rowsInTopHalf
struct XilinxConfigurationAccessPort::SelectedOptions	selectedOptions
struct {
int   fromRow
uint32_t   IDCODE
int   rowsInBottomHalf
int   rowsInTopHalf
int   toRow
}	SLRinfo [MAX_SLRS]
int	toRow

Additional Inherited Members
Public Types inherited from XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >
enum class	MergeOP

Detailed Description

Definition at line 31 of file XilinxSeries7.h.

Constructor & Destructor Documentation

XilinxSeries7()

XilinxSeries7::XilinxSeries7

(

)

Definition at line 31 of file XilinxSeries7.cpp.

{
    initFabric();
}

~XilinxSeries7()

XilinxSeries7::~XilinxSeries7 ( )

virtual

Definition at line 36 of file XilinxSeries7.cpp.

{
}

Member Function Documentation

assembler()

void XilinxSeries7::assembler	(	std::string	,
		std::string
	)

Definition at line 32 of file XS7_Assembler.cpp.

{
    enum FILEFORMAT {FILE_NULL = 0, FILE_BIT, FILE_BIN, FILE_BIT_ASM};
    FILEFORMAT fileformatIn = FILE_NULL, fileformatOut = FILE_NULL;
    
    if(str::iff::stringEndsWith(filenameIn, ".bit"))
        fileformatIn = FILE_BIT;
    if(str::iff::stringEndsWith(filenameIn, ".bin"))
        fileformatIn = FILE_BIN;
    if(str::iff::stringEndsWith(filenameIn, ".bitasm"))
        fileformatIn = FILE_BIT_ASM;
    if(str::iff::stringEndsWith(filenameOut, ".bit"))
        fileformatOut = FILE_BIT;
    if(str::iff::stringEndsWith(filenameOut, ".bin"))
        fileformatOut = FILE_BIN;
    if(str::iff::stringEndsWith(filenameOut, ".bitasm"))
        fileformatOut = FILE_BIT_ASM;
    
    ifstream fin (filenameIn, ifstream::binary);
    if(!fin.good())
        throw runtime_error(string("Could not open file: \"").append(filenameIn).append("\" .\n"));
    
    ofstream fout (filenameOut, ofstream::binary | ofstream::trunc);
    if(!fout.good())
        throw runtime_error(string("Could not open file: \"").append(filenameOut).append("\"!\n"));
    
    if(fileformatIn == FILE_BIT && fileformatOut == FILE_BIT_ASM)
        disassemblerBitToAsm(fin, fout);
    else if(fileformatIn == FILE_BIN && fileformatOut == FILE_BIT_ASM)
        disassemblerBinToAsm(filenameIn, fin, fout);
    else if(fileformatIn == FILE_BIT_ASM && fileformatOut == FILE_BIT)
        assemblerAsmToBit(fin, fout);
    else if(fileformatIn == FILE_BIT_ASM && fileformatOut == FILE_BIN)
        assemblerAsmToBin(fin, fout);
    else
        throw runtime_error(string("Unknown Xilinx Series 7 assembler operation between file formats. See \"byteman -h assembly\".\n"));
    fin.close();
    fout.close();
}

References str::iff::stringEndsWith().

Here is the call graph for this function:

assemblerAsmTo()

void XilinxSeries7::assemblerAsmTo	(	std::ifstream &	,
		std::ofstream &
	)

Definition at line 125 of file XS7_Assembler.cpp.

{
    outputCAPheaderConstant(fout, loadedBitstreamEndianness);
    
    XCAP::Register regAddr = XCAP::Register::UNDEFINED;
    int frameCount = 0;
    int slr = 0, b = 7, r = 0, c = 0, m = 0;
    for (string line; getline(fin, line); ) {
        if(line.at(line.find_first_not_of(" \t")) == '#')// if #, skip that line as comment
            continue;
        transform(line.begin(), line.end(), line.begin(), ::toupper);
        replace(line.begin(), line.end(), '=',' ');
        replace(line.begin(), line.end(), '#',' ');
        replace(line.begin(), line.end(), ',', ' ');
        if(str::iff::stringContains(line, "SYNC") && (!str::iff::stringContains(line, "DESYNC"))){
            XCAP_writeSYNQ(fout, loadedBitstreamEndianness);
        }
        else if(str::iff::stringContains(line, ".WORD")){
            uint32_t wordValue;
            if(!str::parse::multipleUints(line, wordValue))wordValue = 0;
            FileIO::write32(fout, wordValue, loadedBitstreamEndianness);
        }
        else if(str::iff::stringContains(line, ".BYTE")){
            uint32_t value;
            if(!str::parse::multipleUints(line, value))value = 0;
            uint32_t byteValue = value % 256;
            FileIO::write8(fout, byteValue, loadedBitstreamEndianness);
        }
        else if(str::iff::stringContains(line, "NOP")){
            int nopHiddenValue;
            if(!str::parse::multipleInts(line, nopHiddenValue))nopHiddenValue = 0;
            XCAP_writeNOP(fout, 1, nopHiddenValue, loadedBitstreamEndianness);
        }
        else if(str::iff::stringContains(line, "RESERVED")){
            int reservedHiddenValue;
            if(!str::parse::multipleInts(line, reservedHiddenValue))reservedHiddenValue = 0;
            XCAP_writeRESERVED(fout, 1, reservedHiddenValue, loadedBitstreamEndianness);
        }
        else if(str::iff::stringContains(line, "SELECT NEXT SLR")){
            slr++;
            int magic1size;
            if(!str::parse::multipleInts(line, magic1size))magic1size = 0;
            XCAP_writeSelectRegister(fout, XCAP::Register::MAGIC1, loadedBitstreamEndianness);
            XCAP_writeType2(fout, magic1size, loadedBitstreamEndianness);
        }
        else if(str::iff::stringContains(line, "@")){
            XCAP::Register newRegAddr = getXCAPregister(line);
            if(str::iff::stringContains(line, "READ REG @")){
                int readLength;
                if(!str::parse::multipleInts(line, readLength)) readLength = 1; // default read length is 1 if unspecified
                XCAP_writeReadRegister(fout, newRegAddr, readLength, loadedBitstreamEndianness);
            } else {// must be a write then ¯\_(ツ)_/¯
            
                if(newRegAddr == XCAP::Register::UNDEFINED){
                    throw runtime_error(string("Couldn't parse assembly command: \"").append(line).append("\"!"));
                } else if(str::iff::stringContains(line, "SELECT REGISTER")){
                    XCAP_writeSelectRegister(fout, newRegAddr, loadedBitstreamEndianness);
                } else if(newRegAddr == XCAP::Register::FDRI){
                    if(!str::parse::multipleInts(line, frameCount))
                        throw runtime_error(string("FDRI command needs size: \"").append(line).append("\"!"));
                    int wordCount = frameCount * XS7_WORDS_PER_FRAME;
                    if(regAddr == XCAP::Register::FDRI) {
                        XCAP_writeType2(fout, wordCount, loadedBitstreamEndianness);
                    } else {
                        XCAP_writeFDRI1(fout, wordCount, loadedBitstreamEndianness);
                    }
                    if(frameCount > 0){
                        string frameLine;
                        for (string frameLine; getline(fin, frameLine); ) {
                            if(frameLine.at(frameLine.find_first_not_of(" \t")) == '#')// if #, skip that line as comment
                                continue;
                            uint32_t frameData[XS7_WORDS_PER_FRAME];
                            if(!str::parse::arrayOfUints(frameLine, XS7_WORDS_PER_FRAME, &frameData[0]))
                                throw runtime_error(string("Was expecting the data for a full frame on this line: \"").append(frameLine).append("\", because I think there are ").append(to_string(frameCount)).append(" frames left."));
                            //first 3 words are clk, next 90 are the 0-45 and 48-93 data words
                            for (int w = XS7_WORDS_AT_CLK; w < (XS7_WORDS_AT_CLK + XS7_WORDS_BEFORE_CLK) ; w++){
                                FileIO::write32(fout, frameData[w], loadedBitstreamEndianness);
                            }
                            for (int w = 0; w < XS7_WORDS_AT_CLK ; w++){
                                FileIO::write32(fout, frameData[w], loadedBitstreamEndianness);
                            }
                            for (int w = (XS7_WORDS_AT_CLK + XS7_WORDS_BEFORE_CLK); w < XS7_WORDS_PER_FRAME ; w++){
                                FileIO::write32(fout, frameData[w], loadedBitstreamEndianness);
                            }
                            
                            frameCount--;
                            if(frameCount == 0)
                                break;
                        }
                        if(frameCount != 0)
                            throw runtime_error(string("End of file reached while performing FDRI frame writes.!"));
                    }
                } else if(newRegAddr == XCAP::Register::FAR){
                    if(!str::parse::multipleInts(line, b, r, c, m))
                        throw runtime_error(string("Could not parse the new FAR value: \"").append(line).append("\"!"));
                    r += SLRinfo[slr].fromRow;
                    uint32_t farValue = XCAP_getFAR(slr, b, r, c, m);
                    XCAP_writeRegister(fout, XCAP::Register::FAR, farValue, loadedBitstreamEndianness);
                } else {
                    uint32_t newValue;
                    if(!str::parse::multipleUints(line, newValue))
                        throw runtime_error(string("Could not parse the new register value: \"").append(line).append("\"!"));
                    XCAP_writeRegister(fout, newRegAddr, newValue, loadedBitstreamEndianness);
                }
            }
            regAddr = newRegAddr;
        } else {// ! str::iff::stringContains(line, "@")
            //must have been a command then
            XCAP::Command cmdID = getXCAPcommand(line);
            if(cmdID == XCAP::Command::UNDEFINED)
                throw runtime_error(string("Couldn't parse assembly command: \"").append(line).append("\"!"));
            XCAP_writeCommand(fout, cmdID, loadedBitstreamEndianness);
        }
    }
    outputBITheaderLengthField(fout, loadedBitstreamEndianness);
}

References str::parse::arrayOfUints(), XCAP::FAR, XCAP::FDRI, getXCAPcommand(), getXCAPregister(), XCAP::MAGIC1, str::parse::multipleInts(), str::parse::multipleUints(), outputBITheaderLengthField(), outputCAPheaderConstant(), str::replace(), str::iff::stringContains(), Endian::to_string(), XCAP::UNDEFINED, FileIO::write32(), FileIO::write8(), XCAP_getFAR(), XCAP_writeCommand(), XCAP_writeFDRI1(), XCAP_writeNOP(), XCAP_writeReadRegister(), XCAP_writeRegister(), XCAP_writeRESERVED(), XCAP_writeSelectRegister(), XCAP_writeSYNQ(), XCAP_writeType2(), XS7_WORDS_AT_CLK, XS7_WORDS_BEFORE_CLK, and XS7_WORDS_PER_FRAME.

Here is the call graph for this function:

assemblerAsmToBin()

void XilinxSeries7::assemblerAsmToBin	(	std::ifstream &	,
		std::ofstream &
	)

Definition at line 98 of file XS7_Assembler.cpp.

                                                                  {
    assemblerParseHeader(fin);
    
    setDeviceByPartNameOrThrow();
    initializeResourceStringParameters();
    
    assemblerAsmTo(fin, fout);
}

assemblerAsmToBit()

void XilinxSeries7::assemblerAsmToBit	(	std::ifstream &	,
		std::ofstream &
	)

Definition at line 89 of file XS7_Assembler.cpp.

                                                                  {
    assemblerParseHeader(fin);
    
    setDeviceByPartNameOrThrow();
    initializeResourceStringParameters();
    outputBITheader(fout, loadedBitstreamEndianness);
    
    assemblerAsmTo(fin, fout);
}

References outputBITheader().

Here is the call graph for this function:

assemblerParseHeader()

void XilinxSeries7::assemblerParseHeader

(

std::ifstream &

)

Definition at line 107 of file XS7_Assembler.cpp.

{
    for (string line; getline(fin, line); ) {
        auto firstEqPos = line.find_first_of('=');
        if(firstEqPos != string::npos)
            line.replace(firstEqPos, 1, '=',' ');
        
        if(str::iff::stringContains(line, "Name"))designName = str::parse::lastStringWord(line);
        if(str::iff::stringContains(line, "FPGA"))partName = str::parse::lastStringWord(line);
        if(str::iff::stringContains(line, "Date"))fileDate = str::parse::lastStringWord(line);
        if(str::iff::stringContains(line, "Time"))fileTime = str::parse::lastStringWord(line);
        if(str::iff::stringContains(line, "HEADER END"))break;
    }
    log("Design name: " + designName);
    log("FPGA: " + partName);
    log("Date: " + fileDate);
    log("Time: " + fileTime);
}

References str::parse::lastStringWord(), and str::iff::stringContains().

Here is the call graph for this function:

blank()

void XilinxSeries7::blank

(

std::string

)

Definition at line 22 of file XS7_Blank.cpp.

                                      {
    ensureInitializedBitstreamArrays();
    parseParams(params);
    
    blankBuffers();
}

References blankBuffers(), and parseParams().

Here is the call graph for this function:

change()

void XilinxSeries7::change

(

std::string

)

Definition at line 24 of file XS7_Change.cpp.

{
    parseParams(params);
    if(selectedOptions.forceEndianness)
        ensureSelectedEndianness(selectedOptions.forcedEndianness);
    if(selectedOptions.word)
        setBitstreamWord(params);
}

References ensureSelectedEndianness(), parseParams(), and setBitstreamWord().

Here is the call graph for this function:

deviceHelp()

void XilinxSeries7::deviceHelp

(

)

Definition at line 661 of file XS7_Devices.cpp.

{
    if(initializedResourceStringShortPartName == "") {//if no device is initialized
        cout << "A list of currently supported Xilinx Series 7 devices: " << endl;
        #ifdef XS7SPARTAN
        cout << "  Series 7 Spartan: " << endl;
        cout << "    XC7S6, XA7S6, XC7S15, XA7S15, XC7S25, XA7S25, XC7S50, XA7S50, XC7S75, XA7S75, XC7S100, XA7S100" << endl;
        #endif
        #ifdef XS7ARTIX
        cout << "  Series 7 Artix: " << endl;
        cout << "    XC7A12, XA7A12, XC7A15, XA7A15, XC7A25, XA7A25, XC7A35, XA7A35, XC7A50, XQ7A50, XA7A50, " << endl;
        cout << "    XC7A75, XA7A75, XC7A100, XQ7A100, XA7A100, XC7A200, XQ7A200" << endl;
        #endif
        #ifdef XS7ZYNQ
        cout << "  Series 7 Zynq: " << endl;
        cout << "    XC7Z007, XC7Z010, XA7Z010, XC7Z012, XC7Z014, XC7Z015, XC7Z020, XQ7Z020, XA7Z020, " << endl;
        cout << "    XC7Z030, XQ7Z030, XA7Z030, XC7Z035, XC7Z045, XQ7Z045, XC7Z100, XQ7Z100" << endl;
        #endif
        #ifdef XS7KINTEX
        cout << "  Series 7 Kintex: " << endl;
        cout << "    XC7K70, XC7K160, XA7K160, XC7K325, XQ7K325, XC7K355, XC7K410, XQ7K410, XC7K420, XC7K480" << endl;
        #endif
        #ifdef XS7VIRTEX
        cout << "  Series 7 Virtex: " << endl;
        cout << "    XC7V585, XQ7V585, XC7V2000, XC7VX330, XQ7VX330, XC7VX415, XC7VX485, XQ7VX485, XC7VX550, " << endl;
        cout << "    XC7VX690, XQ7VX690, XC7VX980, XQ7VX980, XC7VX1140" << endl;
        #endif
        #ifdef XS7BOARDS
        cout << "  Series 7 Boards: " << endl;
        cout << "    Wizarde, Kintex-7 Connectivity Kit, KC705, KC724, SP701, AC701, Arty A7-35, Arty A7-100, Arty Z7-10, Arty Z7-20, " << endl;
        cout << "    Arty S7-25, Arty S7-50, Basys 3, Pynq Z1, Pynq Z2, Nexys A7-50, Nexys A7-100, Zybo Z7-10, Zybo Z7-20, Cmod A7-15, " << endl;
        cout << "    Cmod A7-35, Cmod S7, ZedBoard, Cora Z7-07, Cora Z7-10, Nexys Video, Genesys 2, Eclypse Z7, USB104, NetFPGA-SUME, " << endl;
        cout << "    VC707, VC709, VC7203, VC7215, VC7222, ZC702, ZC706" << endl;
        #endif
    } else {
        printResourceStringInfo();
    }
}

References printResourceStringInfo().

Here is the call graph for this function:

disassemblerBinToAsm()

void XilinxSeries7::disassemblerBinToAsm	(	std::string	,
		std::ifstream &	,
		std::ofstream &
	)

Definition at line 72 of file XS7_Assembler.cpp.

                                                                                         {
    loadedBitstreamEndianness = parseBitstreamEndianness(fin);
    uint32_t idcode = parseBitstreamIDCODE(fin, loadedBitstreamEndianness);
    setDeviceByIDCODEOrThrow(idcode);
    designName = filenameIn;
    updateDateAndTime();
    
    disassemblerToAsm(fin, fout);
}

References parseBitstreamEndianness(), parseBitstreamIDCODE(), and updateDateAndTime().

Here is the call graph for this function:

disassemblerBitToAsm()

void XilinxSeries7::disassemblerBitToAsm	(	std::ifstream &	,
		std::ofstream &
	)

Definition at line 82 of file XS7_Assembler.cpp.

                                                                      {
    loadedBitstreamEndianness = parseBitstreamEndianness(fin);
    parseBITheader(fin, loadedBitstreamEndianness);
    setDeviceByPartNameOrThrow();
    
    disassemblerToAsm(fin, fout);
}

References parseBITheader(), and parseBitstreamEndianness().

Here is the call graph for this function:

disassemblerToAsm()

void XilinxSeries7::disassemblerToAsm	(	std::ifstream &	,
		std::ofstream &
	)

Definition at line 252 of file XS7_Assembler.cpp.

                                                                   {
    initializeResourceStringParameters();
    disassemblerWriteHeader(fout);
    
    XCAP::Register regAddr = XCAP::Register::UNDEFINED;
    bool synched = false;
    bool aligned = false;
    int wordCount = 0;
    int shadowFrameValid = 0;
    int slr = 0, b = 7, r = 0, c = 0, m = 0;
    //Parse bitstream
    for( ; ; ){
        if(!fin.good()){
            break; // done with the bitstream
        } else {
            if(!synched){
                streamoff startFileOffset = fin.tellg();
                streamoff endFileOffset;
                if(!aligned){
                    if(findBitstreamSyncSequence(fin, loadedBitstreamEndianness)){
                        endFileOffset = fin.tellg() - (streamoff)4;
                        synched = true;
                        aligned = true;
                    } else {//end of bitstream
                        endFileOffset = fin.tellg();
                    }
                } else { //already aligned
                    if(findBitstreamSyncWord(fin, loadedBitstreamEndianness)){
                        endFileOffset = fin.tellg() - (streamoff)4;
                        synched = true;
                    } else {//end of bitstream
                        endFileOffset = fin.tellg();
                    }
                }
                fin.seekg(startFileOffset, fin.beg);
                assemblyOutputData(fin, fout, (endFileOffset - startFileOffset));
                if(synched){
                    FileIO::read32(fin);//discard sync command
                    fout << "SYNC" << endl;
                } else {
                    break; //if still not synched, then we reached end of file
                }
            } else {
                uint32_t instruction = FileIO::read32(fin, loadedBitstreamEndianness);
                int instructionType = XCAP_getInstructionType(instruction);
                XCAP::Operation instructionOPCODE = XCAP_getInstructionOperation(instruction);
                int instructionPayload = XCAP_getInstructionPayload(instruction);
                if(instructionType == 1) {
                    wordCount = XCAP_getInstructionWordCount(instruction);
                    regAddr = XCAP_getInstructionRegister(instruction);
                } else if(instructionType == 2) {
                    wordCount = instructionPayload;
                } else {
                    fout << "0x" << uppercase << hex << setw(8) << setfill('0') << instruction << " (Invalid instruction [invalid type])" << endl;
                    continue;
                }
                
                if(instructionOPCODE == XCAP::Operation::NOP) {
                    if(instructionPayload != 0)
                        fout << "NOP #" << instructionPayload << endl;
                    else
                        fout << "NOP" << endl;
                } else if(instructionOPCODE == XCAP::Operation::RESERVED) {
                    if(instructionPayload != 0)
                        fout << "RESERVED #" << instructionPayload << endl;
                    else
                        fout << "RESERVED" << endl;
                } else if(instructionOPCODE == XCAP::Operation::READ) {
                    fout << "Read Reg @";
                    writeXCAPregisterName(fout, regAddr);
                    fout << " for length #" << wordCount << endl;
                } else { // XCAP::Operation::WRITE
                    if((regAddr == XCAP::Register::FDRI) && (wordCount > 0) && (wordCount % XS7_WORDS_PER_FRAME == 0)) {
                        if(shadowFrameValid) {
                            fout << dec << "# Shadow register contents are written to frame (BlockType=" << b << ", GlobalRowAddress=" << r << ", MajorAddress=" << c << ", MinorAddress=" << m << ") (Frame type: " << getFrameType(b, r, c) << ")." << endl;
                            XCAP_IncrementFAR(slr, b, r, c, m);
                        }
                        shadowFrameValid = 1;
                        int frameCount = (wordCount/XS7_WORDS_PER_FRAME);
                        fout << dec << "@FDRI for #" << frameCount << " frames:" << endl;
                        for(int i = 0 ; i < frameCount ; i++){
                            fout << "# ";
                            if(i == (frameCount-1)) fout << "(This frame data is written to shadow register!)";
                            fout << dec << "Writing frame #" << i << " (BlockType=" << b << ", GlobalRowAddress=" << r << ", MajorAddress=" << c << ", MinorAddress=" << m << ") (Frame type: " << getFrameType(b, r, c) << ") hex data:" << endl;
                            uint32_t frameData[XS7_WORDS_PER_FRAME];
                            for(int w = 0 ; w < XS7_WORDS_PER_FRAME ; w++){
                                frameData[w] = FileIO::read32(fin, loadedBitstreamEndianness);
                            }
                            fout << "CLOCK: ";
                            for(int w = XS7_WORDS_BEFORE_CLK ; w < (XS7_WORDS_BEFORE_CLK + XS7_WORDS_AT_CLK) ; w++){
                                fout << "0x" << uppercase << hex << setw(8) << setfill('0') << frameData[w] << " ";
                            }
                            fout << " ;DATA: ";
                            for(int w = 0 ; w < XS7_WORDS_BEFORE_CLK ; w++){
                                fout << "0x" << uppercase << hex << setw(8) << setfill('0') << frameData[w] << " ";
                            }
                            for(int w = (XS7_WORDS_BEFORE_CLK + XS7_WORDS_AT_CLK) ; w < XS7_WORDS_PER_FRAME ; w++){
                                fout << "0x" << uppercase << hex << setw(8) << setfill('0') << frameData[w] << " ";
                            }
                            fout << endl;
                            XCAP_IncrementFAR(slr, b, r, c, m);
                        }
                    } else if(regAddr == XCAP::Register::CMD && wordCount == 1){
                        uint32_t writeData = FileIO::read32(fin, loadedBitstreamEndianness);
                        writeXCAPcommandName(fout, static_cast<XCAP::Command>(writeData));
                        fout << ";";
                        if(XCAP::Command::DESYNC == static_cast<XCAP::Command>(writeData)){
                            shadowFrameValid = 0;
                            synched = false;
                        }
                        if(XCAP::Command::WCFG == static_cast<XCAP::Command>(writeData)){
                            shadowFrameValid = 0;
                            fout << " (also clears shadow register)";
                        }
                        fout << endl;
                    } else if(regAddr == XCAP::Register::MAGIC1){
                        uint32_t nextInstr = FileIO::read32(fin, loadedBitstreamEndianness);
                        int nextInstrType = XCAP_getInstructionType(nextInstr);
                        XCAP::Operation nextInstrOP = XCAP_getInstructionOperation(nextInstr);
                        int nextInstrPayload = XCAP_getInstructionPayload(nextInstr);
                        if(2 == nextInstrType && XCAP::Operation::WRITE == nextInstrOP && 0 < nextInstrPayload){
                            slr++;
                            synched = false;
                            aligned = false;
                            fout << "Select next SLR for the next #" << dec << nextInstrPayload << " words." << endl;
                        } else {
                            fout << "Bad MAGIC1 instruction" << endl;
                            fin.seekg(-4, ios::cur);//rewind next instruction if not
                        }
                    } else if((instructionType == 1) && (wordCount == 0)){
                        fout << "Select register @";
                        writeXCAPregisterName(fout, regAddr);
                        fout << endl;
                    } else if(wordCount == 1){
                        uint32_t writeData = FileIO::read32(fin, loadedBitstreamEndianness);
                        fout << "@";
                        writeXCAPregisterName(fout, regAddr);
                        if(regAddr == XCAP::Register::FAR) {
                            XCAP_parseFAR(writeData, slr, b, r, c, m);
                            fout << " = BlockType=" << dec << b << " RowAddress=" << (r-SLRinfo[slr].fromRow) << " MajorAddress=" << c << " MinorAddress=" << m << endl;
                        } else {
                            fout << " = 0x" << uppercase << hex << setw(8) << setfill('0') << writeData << endl;
                        }
                    } else {
                        fout << "0x" << uppercase << hex << setw(8) << setfill('0') << instruction << "(Bad instruction)" << endl;
                    }
                } // OP_WRITE
            }// if synched
        } // if fin is still good
    } // for(;;)
}

References assemblyOutputData(), XCAP::CMD, XCAP::DESYNC, XCAP::FAR, XCAP::FDRI, findBitstreamSyncSequence(), findBitstreamSyncWord(), XCAP::MAGIC1, XCAP::NOP, XCAP::READ, FileIO::read32(), XCAP::RESERVED, XCAP::UNDEFINED, XCAP::WCFG, XCAP::WRITE, writeXCAPcommandName(), writeXCAPregisterName(), XCAP_getInstructionOperation(), XCAP_getInstructionPayload(), XCAP_getInstructionRegister(), XCAP_getInstructionType(), XCAP_getInstructionWordCount(), XCAP_IncrementFAR(), XCAP_parseFAR(), XS7_WORDS_AT_CLK, XS7_WORDS_BEFORE_CLK, and XS7_WORDS_PER_FRAME.

Here is the call graph for this function:

disassemblerWriteHeader()

void XilinxSeries7::disassemblerWriteHeader

(

std::ofstream &

)

Definition at line 242 of file XS7_Assembler.cpp.

{
    fout << "--- HEADER BEGIN ---" << endl;
    fout << "Name = \"" << designName << "\"" << endl;
    fout << "FPGA = \"" << partName << "\"" << endl;
    fout << "Date = \"" << fileDate << "\"" << endl;
    fout << "Time = \"" << fileTime << "\"" << endl;
    fout << "--- HEADER END ---" << endl;
}

ensureInitializedBitstreamArrays()

void XilinxSeries7::ensureInitializedBitstreamArrays ( )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 74 of file XilinxSeries7.cpp.

                                                    {
    if(initializedResourceStringShortPartName == "")
        throw runtime_error("The target device needs to be known, before you can manipulate any bitstream!");
    if(initializedBitstreamShortPartName != initializedResourceStringShortPartName){//The device is changed
        initializedBitstreamShortPartName = initializedResourceStringShortPartName;
        if(bitstreamBegin != nullptr)
            delete bitstreamBegin;
 
        initializeResourceStringParameters();
        //Allocate
        int bramPlaneSize = 0;
        int clbPlaneSize = 0;
        for(int r = 0 ; r < numberOfRows ; r++){
            bramPlaneSize += XS7_WORDS_PER_FRAME * (XS7_EXTRA_FRAMES_PER_ROW + numberOfBRAMCols[r] * XS7_FRAMES_PER_BRAM_CONTENT_COLUMN);
            clbPlaneSize += numberOfWordsPerRow[r];
        }
        bitstreamBegin = new uint32_t[clbPlaneSize + bramPlaneSize];
        
        //Calc pointers
        int offset = 0;
        
        for(int slr = 0 ; slr < numberOfSLRs ; slr++){
            int fromGlobalRowTop = SLRinfo[slr].fromRow + SLRinfo[slr].rowsInBottomHalf;
            int toGlobalRowTop = SLRinfo[slr].toRow;
            int fromGlobalRowBottom = SLRinfo[slr].fromRow + SLRinfo[slr].rowsInBottomHalf - 1;
            int toGlobalRowBottom = SLRinfo[slr].fromRow;
            for(int r = fromGlobalRowTop ; r <= toGlobalRowTop ; r++){
                for(int c = 0 ; c < numberOfCols[r] ; c++){
                    bitstreamCLB[r][c] = &bitstreamBegin[offset];
                    offset += LUT_numberOfFramesForResourceLetter[(uint8_t)resourceString[r][c]] * XS7_WORDS_PER_FRAME;
                }
            }
            for(int r = fromGlobalRowBottom ; r >= toGlobalRowBottom ; r--){
                for(int c = 0 ; c < numberOfCols[r] ; c++){
                    bitstreamCLB[r][c] = &bitstreamBegin[offset];
                    offset += LUT_numberOfFramesForResourceLetter[(uint8_t)resourceString[r][c]] * XS7_WORDS_PER_FRAME;
                }
            }
            for(int r = fromGlobalRowTop ; r <= toGlobalRowTop ; r++){
                for(int c = 0 ; c < numberOfBRAMCols[r] ; c++){
                    bitstreamBRAM[r][c] = &bitstreamBegin[offset];
                    offset += XS7_FRAMES_PER_BRAM_CONTENT_COLUMN*XS7_WORDS_PER_FRAME;
                }
                bitstreamBRAM[r][numberOfBRAMCols[r]] = &bitstreamBegin[offset];
                offset += XS7_EXTRA_FRAMES_PER_ROW * XS7_WORDS_PER_FRAME;
            }
            for(int r = fromGlobalRowBottom ; r >= toGlobalRowBottom ; r--){
                for(int c = 0 ; c < numberOfBRAMCols[r] ; c++){
                    bitstreamBRAM[r][c] = &bitstreamBegin[offset];
                    offset += XS7_FRAMES_PER_BRAM_CONTENT_COLUMN*XS7_WORDS_PER_FRAME;
                }
                bitstreamBRAM[r][numberOfBRAMCols[r]] = &bitstreamBegin[offset];
                offset += XS7_EXTRA_FRAMES_PER_ROW * XS7_WORDS_PER_FRAME;
            }
        }
        
        bitstreamEnd = &bitstreamBegin[offset];
        bitstreamHasValidData = false;
        log("Reserved " + to_string(clbPlaneSize + bramPlaneSize) + " words for the bitstream buffers of device \"" + partName + "\"");
    }
}

References Endian::to_string(), XS7_EXTRA_FRAMES_PER_ROW, XS7_FRAMES_PER_BRAM_CONTENT_COLUMN, and XS7_WORDS_PER_FRAME.

Here is the call graph for this function:

getDeviceByIDCODE()

int XilinxSeries7::getDeviceByIDCODE ( int  IDCODE )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 58 of file XS7_Devices.cpp.

{
    //Series 7 Spartan
    #ifdef XS7SPARTAN
    if(IDCODE == XC7S6_IDCODE)
        return XS7_DEVICE_XC7S6;
    if(IDCODE == XC7S15_IDCODE)
        return XS7_DEVICE_XC7S15;
    if(IDCODE == XC7S25_IDCODE)
        return XS7_DEVICE_XC7S25;
    if(IDCODE == XC7S50_IDCODE)
        return XS7_DEVICE_XC7S50;
    if(IDCODE == XC7S75_IDCODE)
        return XS7_DEVICE_XC7S75;
    if(IDCODE == XC7S100_IDCODE)
        return XS7_DEVICE_XC7S100;
    #endif
    //Series 7 Artix
    #ifdef XS7ARTIX
    if(IDCODE == XC7A12_IDCODE)
        return XS7_DEVICE_XC7A12;
    if(IDCODE == XC7A15_IDCODE)
        return XS7_DEVICE_XC7A15;
    if(IDCODE == XC7A25_IDCODE)
        return XS7_DEVICE_XC7A25;
    if(IDCODE == XC7A35_IDCODE)
        return XS7_DEVICE_XC7A35;
    if(IDCODE == XC7A50_IDCODE)
        return XS7_DEVICE_XC7A50;
    if(IDCODE == XC7A75_IDCODE)
        return XS7_DEVICE_XC7A75;
    if(IDCODE == XC7A100_IDCODE)
        return XS7_DEVICE_XC7A100;
    if(IDCODE == XC7A200_IDCODE)
        return XS7_DEVICE_XC7A200;
    #endif
    //Series 7 Zynq
    #ifdef XS7ZYNQ
    if(IDCODE == XC7Z007_IDCODE)
        return XS7_DEVICE_XC7Z007;
    if(IDCODE == XC7Z010_IDCODE)
        return XS7_DEVICE_XC7Z010;
    if(IDCODE == XC7Z012_IDCODE)
        return XS7_DEVICE_XC7Z012;
    if(IDCODE == XC7Z014_IDCODE)
        return XS7_DEVICE_XC7Z014;
    if(IDCODE == XC7Z015_IDCODE)
        return XS7_DEVICE_XC7Z015;
    if(IDCODE == XC7Z020_IDCODE)
        return XS7_DEVICE_XC7Z020;
    if(IDCODE == XC7Z030_IDCODE)
        return XS7_DEVICE_XC7Z030;
    if(IDCODE == XC7Z035_IDCODE)
        return XS7_DEVICE_XC7Z035;
    if(IDCODE == XC7Z045_IDCODE)
        return XS7_DEVICE_XC7Z045;
    if(IDCODE == XC7Z100_IDCODE)
        return XS7_DEVICE_XC7Z100;
    #endif
    //Series 7 Kintex
    #ifdef XS7KINTEX
    if(IDCODE == XC7K70_IDCODE)
        return XS7_DEVICE_XC7K70;
    if(IDCODE == XC7K160_IDCODE)
        return XS7_DEVICE_XC7K160;
    if(IDCODE == XC7K325_IDCODE)
        return XS7_DEVICE_XC7K325;
    if(IDCODE == XC7K355_IDCODE)
        return XS7_DEVICE_XC7K355;
    if(IDCODE == XC7K410_IDCODE)
        return XS7_DEVICE_XC7K410;
    if(IDCODE == XC7K420_IDCODE)
        return XS7_DEVICE_XC7K420;
    if(IDCODE == XC7K480_IDCODE)
        return XS7_DEVICE_XC7K480;
    #endif
    //Series 7 Virtex
    #ifdef XS7VIRTEX
    if(IDCODE == XC7V585_IDCODE)
        return XS7_DEVICE_XC7V585;
    if(IDCODE == XC7V2000_IDCODE)
        return XS7_DEVICE_XC7V2000;
    if(IDCODE == XC7VH580_IDCODE)
        return XS7_DEVICE_XC7VH580;
    if(IDCODE == XC7VH870_IDCODE)
        return XS7_DEVICE_XC7VH870;
    if(IDCODE == XC7VX330_IDCODE)
        return XS7_DEVICE_XC7VX330;
    if(IDCODE == XC7VX415_IDCODE)
        return XS7_DEVICE_XC7VX415;
    if(IDCODE == XC7VX485_IDCODE)
        return XS7_DEVICE_XC7VX485;
    if(IDCODE == XC7VX550_IDCODE)
        return XS7_DEVICE_XC7VX550;
    if(IDCODE == XC7VX690_IDCODE)
        return XS7_DEVICE_XC7VX690;
    if(IDCODE == XC7VX980_IDCODE)
        return XS7_DEVICE_XC7VX980;
    if(IDCODE == XC7VX1140_IDCODE)
        return XS7_DEVICE_XC7VX1140;
    #endif
 
    return XS7_DEVICE_NULL;
}

References XC7A100_IDCODE, XC7A12_IDCODE, XC7A15_IDCODE, XC7A200_IDCODE, XC7A25_IDCODE, XC7A35_IDCODE, XC7A50_IDCODE, XC7A75_IDCODE, XC7K160_IDCODE, XC7K325_IDCODE, XC7K355_IDCODE, XC7K410_IDCODE, XC7K420_IDCODE, XC7K480_IDCODE, XC7K70_IDCODE, XC7S100_IDCODE, XC7S15_IDCODE, XC7S25_IDCODE, XC7S50_IDCODE, XC7S6_IDCODE, XC7S75_IDCODE, XC7V2000_IDCODE, XC7V585_IDCODE, XC7VH580_IDCODE, XC7VH870_IDCODE, XC7VX1140_IDCODE, XC7VX330_IDCODE, XC7VX415_IDCODE, XC7VX485_IDCODE, XC7VX550_IDCODE, XC7VX690_IDCODE, XC7VX980_IDCODE, XC7Z007_IDCODE, XC7Z010_IDCODE, XC7Z012_IDCODE, XC7Z014_IDCODE, XC7Z015_IDCODE, XC7Z020_IDCODE, XC7Z030_IDCODE, XC7Z035_IDCODE, XC7Z045_IDCODE, XC7Z100_IDCODE, XS7_DEVICE_NULL, XS7_DEVICE_XC7A100, XS7_DEVICE_XC7A12, XS7_DEVICE_XC7A15, XS7_DEVICE_XC7A200, XS7_DEVICE_XC7A25, XS7_DEVICE_XC7A35, XS7_DEVICE_XC7A50, XS7_DEVICE_XC7A75, XS7_DEVICE_XC7K160, XS7_DEVICE_XC7K325, XS7_DEVICE_XC7K355, XS7_DEVICE_XC7K410, XS7_DEVICE_XC7K420, XS7_DEVICE_XC7K480, XS7_DEVICE_XC7K70, XS7_DEVICE_XC7S100, XS7_DEVICE_XC7S15, XS7_DEVICE_XC7S25, XS7_DEVICE_XC7S50, XS7_DEVICE_XC7S6, XS7_DEVICE_XC7S75, XS7_DEVICE_XC7V2000, XS7_DEVICE_XC7V585, XS7_DEVICE_XC7VH580, XS7_DEVICE_XC7VH870, XS7_DEVICE_XC7VX1140, XS7_DEVICE_XC7VX330, XS7_DEVICE_XC7VX415, XS7_DEVICE_XC7VX485, XS7_DEVICE_XC7VX550, XS7_DEVICE_XC7VX690, XS7_DEVICE_XC7VX980, XS7_DEVICE_XC7Z007, XS7_DEVICE_XC7Z010, XS7_DEVICE_XC7Z012, XS7_DEVICE_XC7Z014, XS7_DEVICE_XC7Z015, XS7_DEVICE_XC7Z020, XS7_DEVICE_XC7Z030, XS7_DEVICE_XC7Z035, XS7_DEVICE_XC7Z045, and XS7_DEVICE_XC7Z100.

getDeviceByIDCODEorThrow()

int XilinxSeries7::getDeviceByIDCODEorThrow ( int  IDCODE )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 28 of file XS7_Devices.cpp.

{
    int deviceID = getDeviceByIDCODE(IDCODE);
    if(deviceID == XS7_DEVICE_NULL)
        throw runtime_error(string("Unknown device with IDCODE = ").append(to_string(IDCODE)).append(" . Maybe the device is not Xilinx Series 7 device?"));
    return deviceID;
}

References Endian::to_string(), and XS7_DEVICE_NULL.

Here is the call graph for this function:

getDeviceByName()

int XilinxSeries7::getDeviceByName ( std::string  )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 162 of file XS7_Devices.cpp.

{
    name = str::removeSpaces(name);
    name = str::stringToLower(name);
    
    //Series 7 Spartan
    #ifdef XS7SPARTAN
        if(str::iff::stringContains(name, XC7S6_NAME))
            return XS7_DEVICE_XC7S6;
        if(str::iff::stringContains(name, XC7S15_NAME))
            return XS7_DEVICE_XC7S15;
        if(str::iff::stringContains(name, XC7S25_NAME))
            return XS7_DEVICE_XC7S25;
        if(str::iff::stringContains(name, XC7S50_NAME))
            return XS7_DEVICE_XC7S50;
        if(str::iff::stringContains(name, XC7S75_NAME))
            return XS7_DEVICE_XC7S75;
        if(str::iff::stringContains(name, XC7S100_NAME))
            return XS7_DEVICE_XC7S100;
    #endif
    //Series 7 Artix
    #ifdef XS7ARTIX
        if(str::iff::stringContains(name, XC7A12_NAME))
            return XS7_DEVICE_XC7A12;
        if(str::iff::stringContains(name, XC7A15_NAME))
            return XS7_DEVICE_XC7A15;
        if(str::iff::stringContains(name, XC7A25_NAME))
            return XS7_DEVICE_XC7A25;
        if(str::iff::stringContains(name, XC7A35_NAME))
            return XS7_DEVICE_XC7A35;
        if(str::iff::stringContains(name, XC7A50_NAME))
            return XS7_DEVICE_XC7A50;
        if(str::iff::stringContains(name, XC7A75_NAME))
            return XS7_DEVICE_XC7A75;
        if(str::iff::stringContains(name, XC7A100_NAME))
            return XS7_DEVICE_XC7A100;
        if(str::iff::stringContains(name, XC7A200_NAME))
            return XS7_DEVICE_XC7A200;
    #endif
    //Series 7 Zynq
    #ifdef XS7ZYNQ
        if(str::iff::stringContains(name, XC7Z007_NAME))
            return XS7_DEVICE_XC7Z007;
        if(str::iff::stringContains(name, XC7Z010_NAME))
            return XS7_DEVICE_XC7Z010;
        if(str::iff::stringContains(name, XC7Z012_NAME))
            return XS7_DEVICE_XC7Z012;
        if(str::iff::stringContains(name, XC7Z014_NAME))
            return XS7_DEVICE_XC7Z014;
        if(str::iff::stringContains(name, XC7Z015_NAME))
            return XS7_DEVICE_XC7Z015;
        if(str::iff::stringContains(name, XC7Z020_NAME))
            return XS7_DEVICE_XC7Z020;
        if(str::iff::stringContains(name, XC7Z030_NAME))
            return XS7_DEVICE_XC7Z030;
        if(str::iff::stringContains(name, XC7Z035_NAME))
            return XS7_DEVICE_XC7Z035;
        if(str::iff::stringContains(name, XC7Z045_NAME))
            return XS7_DEVICE_XC7Z045;
        if(str::iff::stringContains(name, XC7Z100_NAME))
            return XS7_DEVICE_XC7Z100;
    #endif
    //Series 7 Kintex
    #ifdef XS7KINTEX
        if(str::iff::stringContains(name, XC7K70_NAME))
            return XS7_DEVICE_XC7K70;
        if(str::iff::stringContains(name, XC7K160_NAME))
            return XS7_DEVICE_XC7K160;
        if(str::iff::stringContains(name, XC7K325_NAME))
            return XS7_DEVICE_XC7K325;
        if(str::iff::stringContains(name, XC7K355_NAME))
            return XS7_DEVICE_XC7K355;
        if(str::iff::stringContains(name, XC7K410_NAME))
            return XS7_DEVICE_XC7K410;
        if(str::iff::stringContains(name, XC7K420_NAME))
            return XS7_DEVICE_XC7K420;
        if(str::iff::stringContains(name, XC7K480_NAME))
            return XS7_DEVICE_XC7K480;
    #endif
    //Series 7 Virtex
    #ifdef XS7VIRTEX
        if(str::iff::stringContains(name, XC7V585_NAME))
            return XS7_DEVICE_XC7V585;
        if(str::iff::stringContains(name, XC7V2000_NAME))
            return XS7_DEVICE_XC7V2000;
        if(str::iff::stringContains(name, XC7VH580_NAME))
            return XS7_DEVICE_XC7VH580;
        if(str::iff::stringContains(name, XC7VH870_NAME))
            return XS7_DEVICE_XC7VH870;
        if(str::iff::stringContains(name, XC7VX330_NAME))
            return XS7_DEVICE_XC7VX330;
        if(str::iff::stringContains(name, XC7VX415_NAME))
            return XS7_DEVICE_XC7VX415;
        if(str::iff::stringContains(name, XC7VX485_NAME))
            return XS7_DEVICE_XC7VX485;
        if(str::iff::stringContains(name, XC7VX550_NAME))
            return XS7_DEVICE_XC7VX550;
        if(str::iff::stringContains(name, XC7VX690_NAME))
            return XS7_DEVICE_XC7VX690;
        if(str::iff::stringContains(name, XC7VX980_NAME))
            return XS7_DEVICE_XC7VX980;
        if(str::iff::stringContains(name, XC7VX1140_NAME))
            return XS7_DEVICE_XC7VX1140;
    #endif
    //Series 7 Boards
    #ifdef XS7BOARDS
        if(str::iff::stringContains(name, "wizarde"))
            return XS7_DEVICE_WIZARDE;
        if(str::iff::stringContains(name, "kintex-7connectivity", "kintex7connectivity"))
            return XS7_DEVICE_KINTEX7CONNECTIVITY;
        if(str::iff::stringContains(name, "kc705", "kintex-7evaluation", "kintex7evaluation", "kintex-7embedded", "kintex7embedded"))
            return XS7_DEVICE_KC705;
        if(str::iff::stringContains(name, "kc724", "kintex-7characterization", "kintex7characterization"))
            return XS7_DEVICE_KC724;
        if(str::iff::stringContains(name, "sp701"))
            return XS7_DEVICE_SP701;
        if(str::iff::stringContains(name, "ac701"))
            return XS7_DEVICE_AC701;
        if(str::iff::stringContains(name, "artya7-35", "artya735", "arty35"))
            return XS7_DEVICE_ARTY_A35;
        if(str::iff::stringContains(name, "artya7-100", "artya7100", "arty100"))
            return XS7_DEVICE_ARTY_A100;
        if(str::iff::stringContains(name, "artyz7-10", "artyz710", "arty10"))
            return XS7_DEVICE_ARTY_Z10;
        if(str::iff::stringContains(name, "artyz7-20", "artyz720", "arty20"))
            return XS7_DEVICE_ARTY_Z20;
        if(str::iff::stringContains(name, "artys7-25", "artys725", "arty25"))
            return XS7_DEVICE_ARTY_S25;
        if(str::iff::stringContains(name, "artys7-50", "artys750", "arty50"))
            return XS7_DEVICE_ARTY_S50;
        if(str::iff::stringContains(name, "basys3"))
            return XS7_DEVICE_BASYS3;
        if(str::iff::stringContains(name, "pynq-z1", "pynqz1"))
            return XS7_DEVICE_PYNQ_Z1;
        if(str::iff::stringContains(name, "pynq-z2", "pynqz2"))
            return XS7_DEVICE_PYNQ_Z2;
        if(str::iff::stringContains(name, "nexysa7-50", "nexysa750", "nexys50"))
            return XS7_DEVICE_NEXYS_A50;
        if(str::iff::stringContains(name, "nexysa7-100", "nexysa7100", "nexys100"))
            return XS7_DEVICE_NEXYS_A100;
        if(str::iff::stringContains(name, "zyboz7-10", "zyboz710", "zybo10"))
            return XS7_DEVICE_ZYBO_Z10;
        if(str::iff::stringContains(name, "zyboz7-20", "zyboz720", "zybo20"))
            return XS7_DEVICE_ZYBO_Z20;
        if(str::iff::stringContains(name, "cmoda7-15", "cmoda715", "cmod15"))
            return XS7_DEVICE_CMOD_A15;
        if(str::iff::stringContains(name, "cmoda7-35", "cmoda735", "cmod35"))
            return XS7_DEVICE_CMOD_A35;
        if(str::iff::stringContains(name, "cmods7-25", "cmods725", "cmod25", "cmods"))
            return XS7_DEVICE_CMOD_S25;
        if(str::iff::stringContains(name, "zedboard"))
            return XS7_DEVICE_ZEDBOARD;
        if(str::iff::stringContains(name, "coraz7-07", "coraz707", "cora07", "cora7"))
            return XS7_DEVICE_CORA_Z7;
        if(str::iff::stringContains(name, "coraz7-10", "coraz710", "cora10"))
            return XS7_DEVICE_CORA_Z10;
        if(str::iff::stringContains(name, "nexysvideo"))
            return XS7_DEVICE_NEXYS_VIDEO;
        if(str::iff::stringContains(name, "genesys2"))
            return XS7_DEVICE_ARTY_GENESYS2;
        if(str::iff::stringContains(name, "eclypsez7"))
            return XS7_DEVICE_ECLYPSE_Z7;
        if(str::iff::stringContains(name, "usb104"))
            return XS7_DEVICE_USB104;
        if(str::iff::stringContains(name, "netfpga-sume", "netfpgasume"))
            return XS7_DEVICE_NETFPGA_SUME;
        if(str::iff::stringContains(name, "vc707"))
            return XS7_DEVICE_VC707;
        if(str::iff::stringContains(name, "vc709"))
            return XS7_DEVICE_VC709;
        if(str::iff::stringContains(name, "vc7215"))
            return XS7_DEVICE_VC7215;
        if(str::iff::stringContains(name, "vc7203"))
            return XS7_DEVICE_VC7203;
        if(str::iff::stringContains(name, "vc7222"))
            return XS7_DEVICE_VC7222;
        if(str::iff::stringContains(name, "zc702"))
            return XS7_DEVICE_ZC702;
        if(str::iff::stringContains(name, "zc706"))
            return XS7_DEVICE_ZC706;
        
        
    #endif
    return XS7_DEVICE_NULL;
}

References str::removeSpaces(), str::iff::stringContains(), str::stringToLower(), XC7A100_NAME, XC7A12_NAME, XC7A15_NAME, XC7A200_NAME, XC7A25_NAME, XC7A35_NAME, XC7A50_NAME, XC7A75_NAME, XC7K160_NAME, XC7K325_NAME, XC7K355_NAME, XC7K410_NAME, XC7K420_NAME, XC7K480_NAME, XC7K70_NAME, XC7S100_NAME, XC7S15_NAME, XC7S25_NAME, XC7S50_NAME, XC7S6_NAME, XC7S75_NAME, XC7V2000_NAME, XC7V585_NAME, XC7VH580_NAME, XC7VH870_NAME, XC7VX1140_NAME, XC7VX330_NAME, XC7VX415_NAME, XC7VX485_NAME, XC7VX550_NAME, XC7VX690_NAME, XC7VX980_NAME, XC7Z007_NAME, XC7Z010_NAME, XC7Z012_NAME, XC7Z014_NAME, XC7Z015_NAME, XC7Z020_NAME, XC7Z030_NAME, XC7Z035_NAME, XC7Z045_NAME, XC7Z100_NAME, XS7_DEVICE_AC701, XS7_DEVICE_ARTY_A100, XS7_DEVICE_ARTY_A35, XS7_DEVICE_ARTY_GENESYS2, XS7_DEVICE_ARTY_S25, XS7_DEVICE_ARTY_S50, XS7_DEVICE_ARTY_Z10, XS7_DEVICE_ARTY_Z20, XS7_DEVICE_BASYS3, XS7_DEVICE_CMOD_A15, XS7_DEVICE_CMOD_A35, XS7_DEVICE_CMOD_S25, XS7_DEVICE_CORA_Z10, XS7_DEVICE_CORA_Z7, XS7_DEVICE_ECLYPSE_Z7, XS7_DEVICE_KC705, XS7_DEVICE_KC724, XS7_DEVICE_KINTEX7CONNECTIVITY, XS7_DEVICE_NETFPGA_SUME, XS7_DEVICE_NEXYS_A100, XS7_DEVICE_NEXYS_A50, XS7_DEVICE_NEXYS_VIDEO, XS7_DEVICE_NULL, XS7_DEVICE_PYNQ_Z1, XS7_DEVICE_PYNQ_Z2, XS7_DEVICE_SP701, XS7_DEVICE_USB104, XS7_DEVICE_VC707, XS7_DEVICE_VC709, XS7_DEVICE_VC7203, XS7_DEVICE_VC7215, XS7_DEVICE_VC7222, XS7_DEVICE_WIZARDE, XS7_DEVICE_XC7A100, XS7_DEVICE_XC7A12, XS7_DEVICE_XC7A15, XS7_DEVICE_XC7A200, XS7_DEVICE_XC7A25, XS7_DEVICE_XC7A35, XS7_DEVICE_XC7A50, XS7_DEVICE_XC7A75, XS7_DEVICE_XC7K160, XS7_DEVICE_XC7K325, XS7_DEVICE_XC7K355, XS7_DEVICE_XC7K410, XS7_DEVICE_XC7K420, XS7_DEVICE_XC7K480, XS7_DEVICE_XC7K70, XS7_DEVICE_XC7S100, XS7_DEVICE_XC7S15, XS7_DEVICE_XC7S25, XS7_DEVICE_XC7S50, XS7_DEVICE_XC7S6, XS7_DEVICE_XC7S75, XS7_DEVICE_XC7V2000, XS7_DEVICE_XC7V585, XS7_DEVICE_XC7VH580, XS7_DEVICE_XC7VH870, XS7_DEVICE_XC7VX1140, XS7_DEVICE_XC7VX330, XS7_DEVICE_XC7VX415, XS7_DEVICE_XC7VX485, XS7_DEVICE_XC7VX550, XS7_DEVICE_XC7VX690, XS7_DEVICE_XC7VX980, XS7_DEVICE_XC7Z007, XS7_DEVICE_XC7Z010, XS7_DEVICE_XC7Z012, XS7_DEVICE_XC7Z014, XS7_DEVICE_XC7Z015, XS7_DEVICE_XC7Z020, XS7_DEVICE_XC7Z030, XS7_DEVICE_XC7Z035, XS7_DEVICE_XC7Z045, XS7_DEVICE_XC7Z100, XS7_DEVICE_ZC702, XS7_DEVICE_ZC706, XS7_DEVICE_ZEDBOARD, XS7_DEVICE_ZYBO_Z10, and XS7_DEVICE_ZYBO_Z20.

Here is the call graph for this function:

getDeviceByNameOrThrow()

int XilinxSeries7::getDeviceByNameOrThrow ( std::string  )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 36 of file XS7_Devices.cpp.

{
    int deviceID = getDeviceByName(name);
    if(deviceID == XS7_DEVICE_NULL)
        throw runtime_error(string("Unknown device: ").append(name).append(". Maybe the device is not Xilinx Series 7 device?"));
    return deviceID;
}

References XS7_DEVICE_NULL.

getFrameType()

string XilinxSeries7::getFrameType ( int  blockType, int  rowAddress, int  columnAddress  )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 136 of file XilinxSeries7.cpp.

                                                                                  {
    if(XS7_BLOCKTYPE_BLOCKRAM == blockType)
        return "BlockRAM Contents";
    else if(XS7_BLOCKTYPE_LOGIC == blockType)
        return LUT_typeOfFrameForResourceLetter[(uint8_t)resourceString[rowAddress][columnAddress]];
    else
        return "Unknown";
}

References XS7_BLOCKTYPE_BLOCKRAM, and XS7_BLOCKTYPE_LOGIC.

initFabric()

void XilinxSeries7::initFabric

(

)

Definition at line 22 of file XS7_Fabric.cpp.

                              {
    setFabricChar(char(0), 0, "EndedLine", true);
    setFabricChar(char(1), XS7_EXTRA_FRAMES_PER_ROW, "EndOfLine", true);
    //The Xilinx Series7 fabric in byteman is encoded in the following letters:
 
    //A-G are brams
    setFabricChar('A', 28, "BRAM_R");                                     //"BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL/HCLK_BRAM";
    setFabricChar('B', 28, "BRAM_L");                                     //"BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL/HCLK_BRAM";
    setFabricChar('C', 28, "PCIE_NULL + BRAM_L");                           //"PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL/HCLK_BRAM";
    setFabricChar('D', 28, "L_TERM_INT_BRAM + BRAM_L");                     //"L_TERM_INT_BRAM + L_TERM_INT_BRAM + L_TERM_INT_BRAM + L_TERM_INT_BRAM + L_TERM_INT_BRAM + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL/HCLK_BRAM";
    setFabricChar('E', 28, "BRAM_L + L_TERM_INT_BRAM");                     //"BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + L_TERM_INT_BRAM + L_TERM_INT_BRAM + L_TERM_INT_BRAM + L_TERM_INT_BRAM + L_TERM_INT_BRAM/HCLK_BRAM";
    setFabricChar('F', 28, "BRAM_L + PCIE_NULL");                           //"BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + BRAM_L + NULL + NULL + NULL + NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL/HCLK_BRAM";
    setFabricChar('G', 28, "PCIE_BOT_LEFT + BRAM_R");                       //"PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_BOT_LEFT + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_TOP_LEFT + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL + BRAM_R + NULL + NULL + NULL + NULL/HCLK_BRAM";
 
    //H-I are DSPs
    setFabricChar('H', 28, "DSP_L");                                      //"DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL + DSP_L + NULL + NULL + NULL + NULL/HCLK_DSP_L";
    setFabricChar('I', 28, "DSP_R");                                      //"DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL + DSP_R + NULL + NULL + NULL + NULL/HCLK_DSP_R";
 
    //L-Z are clb columns
    setFabricChar('L', 36, "CLBLL_L");                                    //"CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L/HCLK_CLB";
    setFabricChar('M', 36, "CLBLM_R");                                    //"CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R/HCLK_CLB";
    setFabricChar('N', 36, "CLBLM_L");                                    //"CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L/HCLK_CLB";
    setFabricChar('O', 36, "CLBLM_L");                                    //"CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R + CLBLL_R/HCLK_CLB";
    setFabricChar('P', 36, "PCIE_INT_INTERFACE_R + CLBLM_R");               //"PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + PCIE_INT_INTERFACE_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R/HCLK_CLB";
    setFabricChar('Q', 36, "PCIE_TOP + CLBLL");                             //"PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_BOT + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_TOP + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L/HCLK_CLB";
    setFabricChar('R', 36, "PCIE_NULL + CLBLM_R");                          //"PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R/HCLK_CLB";
    setFabricChar('S', 36, "CLBLM_R + PCIE3_INT_INTERFACE_R");              //"CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R/HCLK_CLB";
    setFabricChar('T', 36, "CLBLL_L + PCIE3_BOT_RIGHT");                    //"CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE3_BOT_RIGHT + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL/HCLK_CLB";
    setFabricChar('U', 36, "CLBLM_R + PCIE_NULL");                          //"CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL/HCLK_CLB";
    setFabricChar('V', 36, "CLBLL_L + PCIE_NULL");                          //"CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL/HCLK_CLB";
    setFabricChar('W', 36, "PCIE3_INT_INTERFACE_R + CLBLM_R");              //"PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + PCIE3_INT_INTERFACE_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R + CLBLM_R/HCLK_CLB";
    setFabricChar('X', 36, "PCIE3_RIGHT + CLBLL_L");                        //"PCIE3_RIGHT + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE3_TOP_RIGHT + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L/HCLK_CLB";
    setFabricChar('Y', 36, "PCIE_NULL + CLBLL_");                           //"PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L + CLBLL_L/HCLK_CLB";
    setFabricChar('Z', 36, "PCIE_INT_INTERFACE_LEFT_L + CLBLM_L");          //"PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + PCIE_INT_INTERFACE_LEFT_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L + CLBLM_L/HCLK_CLB";
 
    //a-z _' + J-K are I/O and misc
    setFabricChar('a', 42, "LIOB33_SING");                                //"LIOB33_SING + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33 + NULL + LIOB33_SING/HCLK_IOB";
    setFabricChar('b', 30, "CMT_PMV");                                    //"CMT_PMV + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_R + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_R + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_R + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_R + NULL + NULL + NULL + NULL + NULL + CMT_PMV/HCLK_FIFO_L";
    setFabricChar('c', 30, "CLK_PMV + CLK_FEED");                           //"CLK_PMV + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_PMVIOB + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_PMV2_SVT + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_PMV2 + CLK_FEED + CLK_FEED + CLK_FEED + CLK_MTBF2 + CLK_BUFG_BOT_R + NULL + NULL + NULL/CLK_HROW_BOT_R";
    setFabricChar('d', 36, "INT_FEEDTHRU_1");                             //"INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1/HCLK_FEEDTHRU_1";
    setFabricChar('f', 36, "CFG_CENTER_MID");                             //"NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_CENTER_BOT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_CENTER_MID + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_CENTER_TOP + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('g', 30, "VFRAME");                                     //"VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME + VFRAME/HCLK_VFRAME";
    setFabricChar('h', 30, "CMT_PMV_L");                                  //"CMT_PMV_L + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_L + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_L + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_L + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CMT_FIFO_L + NULL + NULL + NULL + NULL + NULL + CMT_PMV_L/HCLK_FIFO_L";
    setFabricChar('i', 42, "RIOB33_SING");                                //"RIOB33_SING + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33 + NULL + RIOB33_SING/HCLK_IOB";
    setFabricChar('j', 30, "CLK_FEED + CLK_PMV");                           //"CLK_FEED + CLK_PMV + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_PMVIOB + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_PMV2_SVT + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_PMV2 + CLK_FEED + CLK_FEED + CLK_FEED + CLK_MTBF2 + CLK_BUFG_BOT_R + NULL + NULL + NULL/CLK_HROW_BOT_R";
    setFabricChar('k', 36, "INT_FEEDTHRU_1 + MONITOR_BOT_FUJI2");           //"INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + MONITOR_BOT_FUJI2 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_MID_FUJI2 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_TOP_FUJI2 + NULL + NULL + NULL + NULL/HCLK_FEEDTHRU_1";
    setFabricChar('l', 30, "CLK_FEED");                                   //"CLK_BUFG_TOP_R + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_TOP_R";
    setFabricChar('m', 32, "GTP_CHANNEL_0");                              //"NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_0 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_1 + NULL + NULL + NULL + NULL + NULL + GTP_COMMON + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_2 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_3 + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('n', 36, "INT_FEEDTHRU_1 + MONITOR_BOT");                 //"INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + MONITOR_BOT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_MID + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_TOP + NULL + NULL + NULL + NULL/HCLK_FEEDTHRU_1";
    setFabricChar('o', 30, "CLK_FEED + CLK_BUFG_REBUF/CLK_HROW_TOP_R");     //"CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_TOP_R";
    setFabricChar('p', 30, "CLK_FEED + CLK_BUFG_REBUF/CLK_HROW_BOT_R");     //"CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_BOT_R";
    setFabricChar('q', 36, "GTP_CHANNEL_0_MID_LEFT");                     //"NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_0_MID_LEFT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_1_MID_LEFT + NULL + NULL + NULL + NULL + NULL + GTP_COMMON_MID_LEFT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_2_MID_LEFT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_3_MID_LEFT + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('r', 36, "GTP_CHANNEL_0_MID_RIGHT");                    //"NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_0_MID_RIGHT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_1_MID_RIGHT + NULL + NULL + NULL + NULL + NULL + GTP_COMMON_MID_RIGHT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_2_MID_RIGHT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTP_CHANNEL_3_MID_RIGHT + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('t', 36, "PSS0");                                       //"PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PSS0 + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PSS1 + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL/NULL";
    setFabricChar('u', 36, "PSS2");                                       //"PSS2 + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PSS3 + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PSS4 + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL + PCIE_NULL/NULL";
    setFabricChar('v', 36, "CFG_SECURITY_BOT_PELE1");                     //"CFG_SECURITY_BOT_PELE1 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_SECURITY_MID_PELE1 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_SECURITY_TOP_PELE1 + NULL + NULL + NULL + NULL + MONITOR_BOT_PELE1 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_MID_PELE1 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_TOP_PELE1 + NULL + NULL + NULL + NULL/HCLK_FEEDTHRU_1_PELE";
    setFabricChar('w', 32, "GTX_CHANNEL_0");                              //"NULL + NULL + NULL + NULL + NULL + GTX_CHANNEL_0 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTX_CHANNEL_1 + NULL + NULL + NULL + NULL + NULL + GTX_COMMON + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTX_CHANNEL_2 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTX_CHANNEL_3 + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('x', 42, "RIOB18_SING");                                //"RIOB18_SING + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18 + NULL + RIOB18_SING/HCLK_IOB";
    setFabricChar('y', 42, "LIOB18_SING");                                //"LIOB18_SING + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18 + NULL + LIOB18_SING/HCLK_IOB";
    setFabricChar('z', 36, "CFG_CENTER_MID_SLAVE");                       //"NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_CENTER_BOT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_CENTER_MID_SLAVE + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CFG_CENTER_TOP_SLAVE + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('J', 30, "CLK_BALI_REBUF + CLK_FEED");                    //"CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_BALI_REBUF + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_BOT_R";
    setFabricChar('K', 36, "INT_FEEDTHRU_1 + MONITOR_BOT_SLAVE");           //"INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + INT_FEEDTHRU_1 + MONITOR_BOT_SLAVE + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_MID + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + MONITOR_TOP + NULL + NULL + NULL + NULL/HCLK_FEEDTHRU_1";
    setFabricChar('_', 32, "GTH_CHANNEL_0");                              //"NULL + NULL + NULL + NULL + NULL + GTH_CHANNEL_0 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTH_CHANNEL_1 + NULL + NULL + NULL + NULL + NULL + GTH_COMMON + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTH_CHANNEL_2 + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + GTH_CHANNEL_3 + NULL + NULL + NULL + NULL + NULL/NULL";
    setFabricChar('e', 30, "CLK_FEED + CLK_BALI_REBUF");                    //"CLK_BUFG_TOP_R + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_BALI_REBUF + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_TOP_R";
    setFabricChar('s', 30, "CLK_FEED + CLK_BALI_REBUF_GTZ_TOP");            //"CLK_BUFG_TOP_R + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_BALI_REBUF_GTZ_TOP + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_TOP_R";
    setFabricChar('#', 30, "CLK_FEED + CLK_BALI_REBUF_GTZ_BOT");            //"CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_BALI_REBUF_GTZ_BOT + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + NULL + NULL + NULL + NULL + NULL + NULL + NULL + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_BUFG_REBUF + NULL + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED + CLK_FEED/CLK_HROW_BOT_R";
 
    //Also in the fabric exist frames that are mapped in bitstreams, but do not physically exist on the device. We encode these as follows:
 
    setFabricChar('0', 36, "EMPTY36", true);
    setFabricChar('1', 28, "EMPTY28", true);
    setFabricChar('2', 42, "EMPTY42", true);
    setFabricChar('3', 30, "EMPTY30", true);
    setFabricChar('4', 28, "EMPTYBRAM28", true);
}

References setFabricChar(), and XS7_EXTRA_FRAMES_PER_ROW.

Here is the call graph for this function:

initializeResourceStringParameters()

void XilinxSeries7::initializeResourceStringParameters ( )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 40 of file XilinxSeries7.cpp.

                                                      {
    if(initializedResourceStringShortPartName == "")
        throw runtime_error("The target device needs to be known, before you can manipulate any bitstream!");
    if(initializedBitstreamParamsShortPartName != initializedResourceStringShortPartName){//The device is changed
        initializedBitstreamParamsShortPartName = initializedResourceStringShortPartName;
        for(int r = 0 ; r < numberOfRows ; r++){
            for((numberOfCols[r] = 0, numberOfFramesBeforeCol[r][0] = 0, numberOfBRAMCols[r] = 0) ; (uint8_t)resourceString[r][numberOfCols[r]] ; numberOfCols[r]++){
                numberOfFramesBeforeCol[r][numberOfCols[r] + 1] = numberOfFramesBeforeCol[r][numberOfCols[r]] + LUT_numberOfFramesForResourceLetter[(uint8_t)resourceString[r][numberOfCols[r]]];
                numberOfBRAMsBeforeCol[r][numberOfCols[r]] = numberOfBRAMCols[r];
                if(str::iff::charIs(resourceString[r][numberOfCols[r]], 'A','B','C','D','E','F','G','4')) //A-G are BlockRAM columns, '4' is empty blockram column
                    numberOfBRAMCols[r]++;
            }
            numberOfFramesPerRow[r] = numberOfFramesBeforeCol[r][numberOfCols[r]];
            numberOfWordsPerRow[r] = numberOfFramesPerRow[r] * XS7_WORDS_PER_FRAME;
            for(int c = numberOfCols[r] + 1 ; c < XS7_MAX_COLS ; c++){
                numberOfFramesBeforeCol[r][c] = numberOfFramesBeforeCol[r][c - 1];
            }
            for(int c = numberOfCols[r] ; c < XS7_MAX_COLS ; c++){
                numberOfBRAMsBeforeCol[r][c] = numberOfBRAMsBeforeCol[r][c - 1];
            }
        }
        
        
        maxNumberOfCols = numberOfCols[0];
        maxNumberOfBRAMCols = numberOfBRAMCols[0];
        for(int r = 1 ; r < numberOfRows ; r++){
            if(maxNumberOfCols < numberOfCols[r])
                maxNumberOfCols = numberOfCols[r];
            if(maxNumberOfBRAMCols < numberOfBRAMCols[r])
                maxNumberOfBRAMCols = numberOfBRAMCols[r];
        }
    }
}

References str::iff::charIs(), XS7_MAX_COLS, and XS7_WORDS_PER_FRAME.

Here is the call graph for this function:

merge()

void XilinxSeries7::merge	(	XilinxSeries7 *	,
		std::string	,
		Rect2D	,
		Coord2D
	)

Definition at line 24 of file XS7_Merge.cpp.

                                                                                            {
    log("Merging bitstreams.");
    //This function uses a pointer to the second XUSP instance, but this pointer should get optimized as it is statically provided in the main function
    parseParams(params);
    
    if(!selectedOptions.partialNotFull){
        log("Merging the whole FPGA");
        src.position = {0, 0};
        dst = {0, 0};
        src.size.row = numberOfRows * XS7_CLB_PER_CLOCK_REGION;
        src.size.col = maxNumberOfCols;
    }
    
    ensureRegionCompatibility(src, dst);
    
    if(src.position.row%XS7_CLB_PER_CLOCK_REGION != 0)
        throw runtime_error(string("Currently only full clock region height relocations are supported (use row numbers multiple of ").append(to_string(XS7_CLB_PER_CLOCK_REGION)).append(")."));
    if(src.size.row%XS7_CLB_PER_CLOCK_REGION != 0)
        throw runtime_error(string("Currently only full clock region height relocations are supported (use row numbers multiple of ").append(to_string(XS7_CLB_PER_CLOCK_REGION)).append(")."));
    if(dst.row%XS7_CLB_PER_CLOCK_REGION != 0)
        throw runtime_error(string("Currently only full clock region height relocations are supported (use row numbers multiple of ").append(to_string(XS7_CLB_PER_CLOCK_REGION)).append(")."));
    
    Endianness endianDifference = Endian::diff(loadedBitstreamEndianness, srcBitstream->loadedBitstreamEndianness);
    
    if((Endianness::NATIVE == endianDifference) && MergeOP::SET == selectedOptions.op)
        fastMerge(srcBitstream, src, dst);
    else
        flexiMerge(srcBitstream, endianDifference, src, dst);
    log("Merging bitstreams complete.");
}

References Coord2D::col, Endian::diff(), ensureRegionCompatibility(), fastMerge(), flexiMerge(), XilinxConfigurationAccessPort< MAX_SLRS, MAX_ROWS, MAX_COLS, MAX_BRAM_COLS, BLOCKTYPE_MAX, BLOCKTYPE_LOGIC, BLOCKTYPE_BLOCKRAM, WORDS_BEFORE_CLK, WORDS_AT_CLK, WORDS_AFTER_CLK, WORDS_PER_FRAME, FRAMES_PER_BRAM_CONTENT_COLUMN, CLB_PER_CLOCK_REGION, BRAM_PER_CLOCK_REGION, EXTRA_FRAMES_PER_ROW, FAR_ENABLE_TOP_BOTTOM_BIT, FAR_TOP_BOTTOM_BIT_SHIFT, FAR_BLOCKTYPE_SHIFT, FAR_BLOCKTYPE_MASK, FAR_ROWADDRESS_SHIFT, FAR_ROWADDRESS_MASK, FAR_COLUMNADDRESS_SHIFT, FAR_COLUMNADDRESS_MASK, FAR_MINORADDRESS_SHIFT, FAR_MINORADDRESS_MASK >::loadedBitstreamEndianness, NATIVE, parseParams(), Rect2D::position, Coord2D::row, Rect2D::size, Endian::to_string(), and XS7_CLB_PER_CLOCK_REGION.

Here is the call graph for this function:

outputBitstreamEmptySLRHeaderSequence()

void XilinxSeries7::outputBitstreamEmptySLRHeaderSequence ( std::ofstream &  , int  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 107 of file XS7_Output.cpp.

{
    XCAP_writeNOP(fout, 132, 0, e);
    //Optional Shutdown + 1 NOP ?
    XCAP_writeCommand(fout, XCAP::Command::RCRC, e);
    XCAP_writeNOP(fout, 2, 0, e);
    XCAP_writeRegister(fout, XCAP::Register::IDCODE, SLRinfo[slr].IDCODE, e);
    XCAP_writeCommand(fout, XCAP::Command::NULLCMD, e);
    
    if((slr + 1) < numberOfSLRs) { // If there are more SLRs, output the magic
        XCAP_writeSelectRegister(fout, XCAP::Register::MAGIC1, e);
        slrMagicInstrLocation[slr] = fout.tellp();
        XCAP_writeType2(fout, 0, e);
    }
}

References XCAP::IDCODE, XCAP::MAGIC1, XCAP::NULLCMD, XCAP::RCRC, XCAP_writeCommand(), XCAP_writeNOP(), XCAP_writeRegister(), XCAP_writeSelectRegister(), and XCAP_writeType2().

Here is the call graph for this function:

outputBitstreamEmptySLRWrapUpSequence()

void XilinxSeries7::outputBitstreamEmptySLRWrapUpSequence ( std::ofstream &  , int  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 123 of file XS7_Output.cpp.

{
    streamoff currentStreamHead = fout.tellp();
    streamoff bypassSize = (currentStreamHead - slrMagicInstrLocation[slr])/4 - 1;
    fout.seekp(slrMagicInstrLocation[slr]);
    FileIO::write32(fout, static_cast<uint32_t>(bypassSize), e);
    fout.seekp(currentStreamHead);
    XCAP_writeNOP(fout, 16, 0, loadedBitstreamEndianness);
    XCAP_writeCommand(fout, XCAP::Command::START, loadedBitstreamEndianness);
    XCAP_writeNOP(fout, 1, 0, loadedBitstreamEndianness);
    XCAP_writeCommand(fout, XCAP::Command::DESYNC, loadedBitstreamEndianness);
    XCAP_writeNOP(fout, 16, 0, loadedBitstreamEndianness);
}

References XCAP::DESYNC, XCAP::START, FileIO::write32(), XCAP_writeCommand(), and XCAP_writeNOP().

Here is the call graph for this function:

outputBitstreamGlobalFooterSequence()

void XilinxSeries7::outputBitstreamGlobalFooterSequence ( std::ofstream &  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 34 of file XS7_Output.cpp.

{
    XCAP_writeNOP(fout, 100, 0, loadedBitstreamEndianness);
}

References XCAP_writeNOP().

Here is the call graph for this function:

outputBitstreamGlobalHeaderSequence()

void XilinxSeries7::outputBitstreamGlobalHeaderSequence ( std::ofstream &  , bool  , Endianness    )

overridevirtual

Written by outputBitstreamSLRHeaderAfterBitstreamSequence(), outputBitstreamEmptySLRHeaderSequence() and used by outputBitstreamSLRWrapUpSequence(), outputBitstreamEmptySLRWrapUpSequence()

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 29 of file XS7_Output.cpp.

{
    
}

outputBitstreamSLRFooterBitstreamSequence()

void XilinxSeries7::outputBitstreamSLRFooterBitstreamSequence ( std::ofstream &  , int  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 52 of file XS7_Output.cpp.

{
    if(fullBitstream) // Add GRESTORE since it is full device bitstream.
    {
        XCAP_writeCommand(fout, XCAP::Command::GRESTORE, e);
        XCAP_writeNOP(fout, 1, 0, e);
    }
    
    XCAP_writeNOP(fout, 1, 0, e);
    uint32_t ctrl0 = XCAP_getCTRL0value(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
    XCAP_writeMaskAndRegister(fout, XCAP::Register::CTRL0, ctrl0, ctrl0, e);
    
    XCAP_writeCommand(fout, XCAP::Command::DGHIGH, e);
    XCAP_writeNOP(fout, 100, 0, e);
    
    XCAP_writeCommand(fout, XCAP::Command::START, e);
    XCAP_writeNOP(fout, 1, 0, e);
    
    XCAP_writeRegister(fout, XCAP::Register::FAR, XCAP_getFarFarInstruction(), e);
    XCAP_writeNOP(fout, 1, 0, e);
    XCAP_writeCommand(fout, XCAP::Command::RCRC, e);
    XCAP_writeNOP(fout, 1, 0, e);
    XCAP_writeCommand(fout, XCAP::Command::DESYNC, e);
    XCAP_writeNOP(fout, 16, 0, e);
}

References XCAP::CTRL0, XCAP::DESYNC, XCAP::DGHIGH, XCAP::FAR, XCAP::GRESTORE, XCAP::RCRC, XCAP::START, XCAP_getCTRL0value(), XCAP_getFarFarInstruction(), XCAP_writeCommand(), XCAP_writeMaskAndRegister(), XCAP_writeNOP(), and XCAP_writeRegister().

Here is the call graph for this function:

outputBitstreamSLRHeaderAfterBitstreamSequence()

void XilinxSeries7::outputBitstreamSLRHeaderAfterBitstreamSequence ( std::ofstream &  , int  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 78 of file XS7_Output.cpp.

{
    if((slr + 1) < numberOfSLRs) { // If there are more SLRs, output the magic
        XCAP_writeNOP(fout, 400, 0, e);
        XCAP_writeSYNQ(fout, e);
        XCAP_writeNOP(fout, 1, 0, e);
        XCAP_writeCommand(fout, XCAP::Command::RCRC, e);
        XCAP_writeNOP(fout, 2, 0, e);
        
        XCAP_writeSelectRegister(fout, XCAP::Register::MAGIC1, e);
        slrMagicInstrLocation[slr] = fout.tellp();
        XCAP_writeType2(fout, 0, e);
    }
}

References XCAP::MAGIC1, XCAP::RCRC, XCAP_writeCommand(), XCAP_writeNOP(), XCAP_writeSelectRegister(), XCAP_writeSYNQ(), and XCAP_writeType2().

Here is the call graph for this function:

outputBitstreamSLRHeaderBitstreamSequence()

void XilinxSeries7::outputBitstreamSLRHeaderBitstreamSequence ( std::ofstream &  , int  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 39 of file XS7_Output.cpp.

{
    XCAP_writeNOP(fout, 132, 0, e);
    //Optional Shutdown + 1 NOP ?
    XCAP_writeCommand(fout, XCAP::Command::RCRC, e);
    XCAP_writeNOP(fout, 2, 0, e);
    XCAP_writeRegister(fout, XCAP::Register::IDCODE, SLRinfo[slr].IDCODE, e);
    XCAP_writeCommand(fout, XCAP::Command::NULLCMD, e);
    uint32_t ctrl0 = XCAP_getCTRL0value(0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0); //disable fallback bitstream, enable overwriting of LUTs
    XCAP_writeMaskAndRegister(fout, XCAP::Register::CTRL0, ctrl0, ctrl0, e);
    XCAP_writeMaskAndRegister(fout, XCAP::Register::CTRL1, 0x20000, 0, e);
}

References XCAP::CTRL0, XCAP::CTRL1, XCAP::IDCODE, XCAP::NULLCMD, XCAP::RCRC, XCAP_getCTRL0value(), XCAP_writeCommand(), XCAP_writeMaskAndRegister(), XCAP_writeNOP(), and XCAP_writeRegister().

Here is the call graph for this function:

outputBitstreamSLRWrapUpSequence()

void XilinxSeries7::outputBitstreamSLRWrapUpSequence ( std::ofstream &  , int  , bool  , Endianness    )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 93 of file XS7_Output.cpp.

{
    streamoff currentStreamHead = fout.tellp();
    streamoff bypassSize = (currentStreamHead - slrMagicInstrLocation[slr])/4 - 1;
    fout.seekp(slrMagicInstrLocation[slr]);
    FileIO::write32(fout, static_cast<uint32_t>(bypassSize), e);
    fout.seekp(currentStreamHead);
    XCAP_writeNOP(fout, 16, 0, loadedBitstreamEndianness);
    XCAP_writeCommand(fout, XCAP::Command::START, loadedBitstreamEndianness);
    XCAP_writeNOP(fout, 1, 0, loadedBitstreamEndianness);
    XCAP_writeCommand(fout, XCAP::Command::DESYNC, loadedBitstreamEndianness);
    XCAP_writeNOP(fout, 16, 0, loadedBitstreamEndianness);
}

References XCAP::DESYNC, XCAP::START, FileIO::write32(), XCAP_writeCommand(), and XCAP_writeNOP().

Here is the call graph for this function:

readBitstream()

void XilinxSeries7::readBitstream

(

std::string

)

Definition at line 27 of file XS7_Input.cpp.

{
    ifstream fin (filename, ifstream::binary);
    if(!fin.good())
        throw runtime_error(string("Could not open file: \"").append(filename).append("\" .\n"));
    log("Reading Xilinx Series 7 bitstream from file \"" + filename + "\"");
    
    if(str::iff::stringEndsWith(filename, ".bit"))
        readBitstreamBIT(fin);
    else if(str::iff::stringEndsWith(filename, ".bin"))
        readBitstreamBIN(fin);
    else if(str::iff::stringEndsWith(filename, ".rbd"))
        readBitstreamRBD(fin);
    else
        throw runtime_error(string("Unknown Xilinx Series 7 file format tried to be read.\n"));
    fin.close();
    log("Xilinx Series 7 bitstream file \"" + filename + "\" read successfully.");
}

References readBitstreamBIN(), readBitstreamBIT(), readBitstreamRBD(), and str::iff::stringEndsWith().

Here is the call graph for this function:

setDevice()

void XilinxSeries7::setDevice ( int  , std::string  = ""  )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 351 of file XS7_Devices.cpp.

{
    clearResourceStringArrays();
    bool customNameSet = false;
    #define setCustomPartName(x) {customNameSet = true; partName = x;}
    switch(deviceID){
        //Series 7 Spartan
        #ifdef XS7SPARTAN
        case XS7_DEVICE_XC7S6:
            XC7S6();
            break;
        case XS7_DEVICE_XC7S15:
            XC7S15();
            break;
        case XS7_DEVICE_XC7S25:
            XC7S25();
            break;
        case XS7_DEVICE_XC7S50:
            XC7S50();
            break;
        case XS7_DEVICE_XC7S75:
            XC7S75();
            break;
        case XS7_DEVICE_XC7S100:
            XC7S100();
            break;
        #endif
        //Series 7 Artix
        #ifdef XS7ARTIX
        case XS7_DEVICE_XC7A12:
            XC7A12();
            break;
        case XS7_DEVICE_XC7A15:
            XC7A15();
            break;
        case XS7_DEVICE_XC7A25:
            XC7A25();
            break;
        case XS7_DEVICE_XC7A35:
            XC7A35();
            break;
        case XS7_DEVICE_XC7A50:
            XC7A50();
            break;
        case XS7_DEVICE_XC7A75:
            XC7A75();
            break;
        case XS7_DEVICE_XC7A100:
            XC7A100();
            break;
        case XS7_DEVICE_XC7A200:
            XC7A200();
            break;
        #endif
        //Series 7 Zynq
        #ifdef XS7ZYNQ
        case XS7_DEVICE_XC7Z007:
            XC7Z007();
            break;
        case XS7_DEVICE_XC7Z010:
            XC7Z010();
            break;
        case XS7_DEVICE_XC7Z012:
            XC7Z012();
            break;
        case XS7_DEVICE_XC7Z014:
            XC7Z014();
            break;
        case XS7_DEVICE_XC7Z015:
            XC7Z015();
            break;
        case XS7_DEVICE_XC7Z020:
            XC7Z020();
            break;
        case XS7_DEVICE_XC7Z030:
            XC7Z030();
            break;
        case XS7_DEVICE_XC7Z035:
            XC7Z035();
            break;
        case XS7_DEVICE_XC7Z045:
            XC7Z045();
            break;
        case XS7_DEVICE_XC7Z100:
            XC7Z100();
            break;
        #endif
        //Series 7 Kintex
        #ifdef XS7KINTEX
        case XS7_DEVICE_XC7K70:
            XC7K70();
            break;
        case XS7_DEVICE_XC7K160:
            XC7K160();
            break;
        case XS7_DEVICE_XC7K325:
            XC7K325();
            break;
        case XS7_DEVICE_XC7K355:
            XC7K355();
            break;
        case XS7_DEVICE_XC7K410:
            XC7K410();
            break;
        case XS7_DEVICE_XC7K420:
            XC7K420();
            break;
        case XS7_DEVICE_XC7K480:
            XC7K480();
            break;
        #endif
        //Series 7 Virtex
        #ifdef XS7VIRTEX
        case XS7_DEVICE_XC7V585:
            XC7V585();
            break;
        case XS7_DEVICE_XC7V2000:
            XC7V2000();
            break;
        case XS7_DEVICE_XC7VH580:
            throw runtime_error("XC7VH580 needs special handling for GTZ SLRs, which is not yet implemented.");
            XC7VH580();
            break;
        case XS7_DEVICE_XC7VH870:
            throw runtime_error("XCV7VH870 needs special handling for GTZ SLRs, which is not yet implemented.");
            XC7VH870();
            break;
        case XS7_DEVICE_XC7VX330:
            XC7VX330();
            break;
        case XS7_DEVICE_XC7VX415:
            XC7VX415();
            break;
        case XS7_DEVICE_XC7VX485:
            XC7VX485();
            break;
        case XS7_DEVICE_XC7VX550:
            XC7VX550();
            break;
        case XS7_DEVICE_XC7VX690:
            XC7VX690();
            break;
        case XS7_DEVICE_XC7VX980:
            XC7VX980();
            break;
        case XS7_DEVICE_XC7VX1140:
            XC7VX1140();
            break;
        #endif
        //Series 7 Boards
        #ifdef XS7BOARDS
        case XS7_DEVICE_WIZARDE:
            XC7Z045();
            setCustomPartName("xc7z045ffg900-2");
            break;
        case XS7_DEVICE_KINTEX7CONNECTIVITY:
            XC7K325();
            setCustomPartName("xc7k325t-2ffg900c");
            break;
        case XS7_DEVICE_KC705:
            XC7K325();
            setCustomPartName("xc7k325t-2ffg900c");
            break;
        case XS7_DEVICE_KC724:
            XC7K325();
            setCustomPartName("xc7k325t-3ffg900e");
            break;
        case XS7_DEVICE_SP701:
            XC7S100();
            setCustomPartName("xc7s100-2fgga676c");
            break;
        case XS7_DEVICE_AC701:
            XC7A200();
            setCustomPartName("xc7a200t-2fbg676c");
            break;
        case XS7_DEVICE_ARTY_A35:
            XC7A35();
            setCustomPartName("xc7a35ticsg324-1l");
            break;
        case XS7_DEVICE_ARTY_A100:
            XC7A100();
            setCustomPartName("xc7a100tcsg324-1");
            break;
        case XS7_DEVICE_ARTY_Z10:
            XC7Z010();
            setCustomPartName("xc7z010-1clg400c");
            break;
        case XS7_DEVICE_ARTY_Z20:
            XC7Z020();
            setCustomPartName("xc7z020-1clg400c");
            break;
        case XS7_DEVICE_ARTY_S25:
            XC7S25();
            setCustomPartName("xc7s25-csga324");
            break;
        case XS7_DEVICE_ARTY_S50:
            XC7S50();
            setCustomPartName("xc7s50-csga324");
            break;
        case XS7_DEVICE_BASYS3:
            XC7A35();
            setCustomPartName("xc7a35t-1cpg236c");
            break;
        case XS7_DEVICE_PYNQ_Z1:
            XC7Z020();
            setCustomPartName("xc7z020-1clg400c");
            break;
        case XS7_DEVICE_PYNQ_Z2:
            XC7Z020();
            setCustomPartName("xc7z020-1clg400c");
            break;
        case XS7_DEVICE_NEXYS_A50:
            XC7A50();
            setCustomPartName("xc7a50t-1csg324c");
            break;
        case XS7_DEVICE_NEXYS_A100:
            XC7A100();
            setCustomPartName("xc7a100t-1csg324c");
            break;
        case XS7_DEVICE_ZYBO_Z10:
            XC7Z010();
            setCustomPartName("xc7z010-1clg400c");
            break;
        case XS7_DEVICE_ZYBO_Z20:
            XC7Z020();
            setCustomPartName("xc7z020-1clg400c");
            break;
        case XS7_DEVICE_CMOD_A15:
            XC7A15();
            setCustomPartName("xc7a15t-1cpg236c");
            break;
        case XS7_DEVICE_CMOD_A35:
            XC7A35();
            setCustomPartName("xc7a35t-1cpg236c");
            break;
        case XS7_DEVICE_CMOD_S25:
            XC7S25();
            setCustomPartName("xc7s25-1csga225c");
            break;
        case XS7_DEVICE_ZEDBOARD:
            XC7Z020();
            setCustomPartName("xc7z020-clg484");
            break;
        case XS7_DEVICE_CORA_Z7:
            XC7Z007();
            setCustomPartName("xc7z007s-1clg400c");
            break;
        case XS7_DEVICE_CORA_Z10:
            XC7Z010();
            setCustomPartName("xc7z010-1clg400c");
            break;
        case XS7_DEVICE_NEXYS_VIDEO:
            XC7A200();
            setCustomPartName("xc7a200t-1sbg484c");
            break;
        case XS7_DEVICE_ARTY_GENESYS2:
            XC7K325();
            setCustomPartName("xc7k325t-2ffg900c");
            break;
        case XS7_DEVICE_ECLYPSE_Z7:
            XC7Z020();
            setCustomPartName("xc7z020-1clg484c");
            break;
        case XS7_DEVICE_USB104:
            XC7A100();
            setCustomPartName("xc7a100t-1csg324i");
            break;
        case XS7_DEVICE_NETFPGA_SUME:
            XC7VX690();
            setCustomPartName("xc7vx690t-3ffg1761c");
            break;
        case XS7_DEVICE_VC707:
            XC7VX485();
            setCustomPartName("xc7vx485t-2ffg1761");
            break;
        case XS7_DEVICE_VC709:
            XC7VX690();
            setCustomPartName("xc7vx690t-2ffg1761c");
            break;
        case XS7_DEVICE_VC7215:
            XC7VX690();
            setCustomPartName("xc7vx690t-3ffg1927e");
            break;
        case XS7_DEVICE_VC7203:
            XC7VX485();
            setCustomPartName("xc7vx485t-3ffg1761e");
            break;
        case XS7_DEVICE_VC7222:
            XC7VH580();
            setCustomPartName("xc7vh580t-g2hcg1155e");
            break;
        case XS7_DEVICE_ZC702:
            XC7Z020();
            setCustomPartName("xc7z020-clg484-1");
            break;
        case XS7_DEVICE_ZC706:
            XC7Z045();
            setCustomPartName("xc7z045-2ffg900c");
            break;
        #endif
        default:throw runtime_error("Unknown device ID.");
    }
    #undef setCustomPartName
    if(!customNameSet) // if we didn't set already a good full name
        if(customPartName != "")// if not empty string
            partName = customPartName;
    
    log("Initialized device resource string for \"" + initializedResourceStringShortPartName + "\"");
}

References clearResourceStringArrays(), XC7A100, XC7A12, XC7A15, XC7A200, XC7A25, XC7A35, XC7A50, XC7A75, XC7K160, XC7K325, XC7K355, XC7K410, XC7K420, XC7K480, XC7K70, XC7S100, XC7S15, XC7S25, XC7S50, XC7S6, XC7S75, XC7V2000, XC7V585, XC7VH580, XC7VH870, XC7VX1140, XC7VX330, XC7VX415, XC7VX485, XC7VX550, XC7VX690, XC7VX980, XC7Z007, XC7Z010, XC7Z012, XC7Z014, XC7Z015, XC7Z020, XC7Z030, XC7Z035, XC7Z045, XC7Z100, XS7_DEVICE_AC701, XS7_DEVICE_ARTY_A100, XS7_DEVICE_ARTY_A35, XS7_DEVICE_ARTY_GENESYS2, XS7_DEVICE_ARTY_S25, XS7_DEVICE_ARTY_S50, XS7_DEVICE_ARTY_Z10, XS7_DEVICE_ARTY_Z20, XS7_DEVICE_BASYS3, XS7_DEVICE_CMOD_A15, XS7_DEVICE_CMOD_A35, XS7_DEVICE_CMOD_S25, XS7_DEVICE_CORA_Z10, XS7_DEVICE_CORA_Z7, XS7_DEVICE_ECLYPSE_Z7, XS7_DEVICE_KC705, XS7_DEVICE_KC724, XS7_DEVICE_KINTEX7CONNECTIVITY, XS7_DEVICE_NETFPGA_SUME, XS7_DEVICE_NEXYS_A100, XS7_DEVICE_NEXYS_A50, XS7_DEVICE_NEXYS_VIDEO, XS7_DEVICE_PYNQ_Z1, XS7_DEVICE_PYNQ_Z2, XS7_DEVICE_SP701, XS7_DEVICE_USB104, XS7_DEVICE_VC707, XS7_DEVICE_VC709, XS7_DEVICE_VC7203, XS7_DEVICE_VC7215, XS7_DEVICE_VC7222, XS7_DEVICE_WIZARDE, XS7_DEVICE_XC7A100, XS7_DEVICE_XC7A12, XS7_DEVICE_XC7A15, XS7_DEVICE_XC7A200, XS7_DEVICE_XC7A25, XS7_DEVICE_XC7A35, XS7_DEVICE_XC7A50, XS7_DEVICE_XC7A75, XS7_DEVICE_XC7K160, XS7_DEVICE_XC7K325, XS7_DEVICE_XC7K355, XS7_DEVICE_XC7K410, XS7_DEVICE_XC7K420, XS7_DEVICE_XC7K480, XS7_DEVICE_XC7K70, XS7_DEVICE_XC7S100, XS7_DEVICE_XC7S15, XS7_DEVICE_XC7S25, XS7_DEVICE_XC7S50, XS7_DEVICE_XC7S6, XS7_DEVICE_XC7S75, XS7_DEVICE_XC7V2000, XS7_DEVICE_XC7V585, XS7_DEVICE_XC7VH580, XS7_DEVICE_XC7VH870, XS7_DEVICE_XC7VX1140, XS7_DEVICE_XC7VX330, XS7_DEVICE_XC7VX415, XS7_DEVICE_XC7VX485, XS7_DEVICE_XC7VX550, XS7_DEVICE_XC7VX690, XS7_DEVICE_XC7VX980, XS7_DEVICE_XC7Z007, XS7_DEVICE_XC7Z010, XS7_DEVICE_XC7Z012, XS7_DEVICE_XC7Z014, XS7_DEVICE_XC7Z015, XS7_DEVICE_XC7Z020, XS7_DEVICE_XC7Z030, XS7_DEVICE_XC7Z035, XS7_DEVICE_XC7Z045, XS7_DEVICE_XC7Z100, XS7_DEVICE_ZC702, XS7_DEVICE_ZC706, XS7_DEVICE_ZEDBOARD, XS7_DEVICE_ZYBO_Z10, and XS7_DEVICE_ZYBO_Z20.

Here is the call graph for this function:

setDeviceByIDCODEOrThrow()

void XilinxSeries7::setDeviceByIDCODEOrThrow ( int  idcode )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 53 of file XS7_Devices.cpp.

                                                      {
    int deviceID = getDeviceByIDCODEorThrow(idcode);
    setDevice(deviceID);
}

setDeviceByNameOrThrow()

void XilinxSeries7::setDeviceByNameOrThrow ( std::string  )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 48 of file XS7_Devices.cpp.

                                                     {
    int deviceID = getDeviceByNameOrThrow(name);
    setDevice(deviceID, name);
}

setDeviceByPartNameOrThrow()

void XilinxSeries7::setDeviceByPartNameOrThrow ( )

overridevirtual

Implements XilinxConfigurationAccessPort< 5, 12, 512, 32, 2, 0, 1, 50, 1, 50,(50+1+50), 128, 50, 10, 2, 1, 22, 23, 0x7, 17, 0x1F, 7, 0x3FF, 0, 0x7F >.

Definition at line 44 of file XS7_Devices.cpp.

                                              {
    setDeviceByNameOrThrow(partName);
}

test()

void XilinxSeries7::test	(	bool	usableFramesOnly,
		bool	testValueEqual,
		uint32_t	testValue
	)

Definition at line 22 of file XS7_Test.cpp.

                                                                                      {
    log("Testing bitstream against value" + to_string(testValue) + ".");
    ensureInitializedBitstreamArrays();
    ensureFramesAre(usableFramesOnly, testValueEqual, testValue);
    log("Testing finished successfully.");
}

References ensureFramesAre(), and Endian::to_string().

Here is the call graph for this function:

writeBitstream()

void XilinxSeries7::writeBitstream	(	std::string	,
		std::string	,
		Rect2D
	)

Creates a new bitstream file and writes the selected regions in it.

• filename Name of the output file.

  Exceptions

  runtime_error

  if args don't define a correct region.

Definition at line 144 of file XS7_Output.cpp.

{
    size_t dotpos = filename.rfind(".");
    if(dotpos == string::npos)
        throw runtime_error(string("Invalid file name: \"").append(filename).append("\"!\n"));
    designName = filename.substr(0, dotpos);
    
    log("Writing Xilinx Series 7 bitstream to file \"" + filename + "\":");
    
    parseParams(params);
    
    if(selectedOptions.partialNotFull) {
        if((cmdRect.position.row % XS7_CLB_PER_CLOCK_REGION != 0) || (cmdRect.size.row % XS7_CLB_PER_CLOCK_REGION != 0))
            throw runtime_error("Currently only full clock region height relocations are supported (use row numbers multiple of 60).");
        if(cmdRect.size.row <= 0 || cmdRect.size.col <= 0)
            throw runtime_error("Invalid output size dimentions.");
    }
    
    ofstream fout (filename, ofstream::binary | ofstream::trunc);
    if(!fout.good())
        throw runtime_error(string("Could not open file: \"").append(filename).append("\"!\n"));
    if(str::iff::stringEndsWith(filename, ".bit"))
        writeBitstreamBIT(fout, cmdRect);
    else if(str::iff::stringEndsWith(filename, ".bin"))
        writeBitstreamBIN(fout, cmdRect);
    else
        throw runtime_error(string("Unknown Xilinx Series 7 file format tried to be written.\n"));
    fout.close();
    log("Xilinx Series 7 bitstream file \"" + filename + "\" written successfully.");
}

References Coord2D::col, parseParams(), Rect2D::position, Coord2D::row, Rect2D::size, str::iff::stringEndsWith(), writeBitstreamBIN(), writeBitstreamBIT(), and XS7_CLB_PER_CLOCK_REGION.

Here is the call graph for this function:

Member Data Documentation

slrMagicInstrLocation

std::streamoff XilinxSeries7::slrMagicInstrLocation[5]

Definition at line 51 of file XilinxSeries7.h.

---

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

• src/Devices/Xilinx/Series7/XilinxSeries7.h
• src/Devices/Xilinx/Series7/XilinxSeries7.cpp
• src/Devices/Xilinx/Series7/XS7_Assembler.cpp
• src/Devices/Xilinx/Series7/XS7_Blank.cpp
• src/Devices/Xilinx/Series7/XS7_Change.cpp
• src/Devices/Xilinx/Series7/XS7_Devices.cpp
• src/Devices/Xilinx/Series7/XS7_Fabric.cpp
• src/Devices/Xilinx/Series7/XS7_Input.cpp
• src/Devices/Xilinx/Series7/XS7_Merge.cpp
• src/Devices/Xilinx/Series7/XS7_Output.cpp
• src/Devices/Xilinx/Series7/XS7_Test.cpp