TORC: torc/bitstream/Spartan3E.hpp Source File

00001 // Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
00002 // $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/bitstream/Spartan3E.hpp $
00003 // $Id: Spartan3E.hpp 10 2011-10-12 18:40:16Z nsteiner $
00004 
00005 // This program is free software: you can redistribute it and/or modify it under the terms of the 
00006 // GNU General Public License as published by the Free Software Foundation, either version 3 of the 
00007 // License, or (at your option) any later version.
00008 // 
00009 // This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
00010 // without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
00011 // the GNU General Public License for more details.
00012 // 
00013 // You should have received a copy of the GNU General Public License along with this program.  If 
00014 // not, see <http://www.gnu.org/licenses/>.
00015 
00016 /// \file
00017 /// \brief Header for the Spartan3E class.
00018 
00019 #ifndef TORC_BITSTREAM_SPARTAN3E_HPP
00020 #define TORC_BITSTREAM_SPARTAN3E_HPP
00021 
00022 #include <boost/cstdint.hpp>
00023 #include <boost/filesystem.hpp>
00024 #include "torc/bitstream/SpartanBitstream.hpp"
00025 #include <map>
00026 
00027 namespace torc { namespace architecture { class DDB; } }
00028 
00029 namespace torc {
00030 namespace bitstream {
00031 
00032 namespace bitstream { class Spartan3EUnitTest; }
00033 namespace bitstream { class Spartan3EFarUnitTest; }
00034 namespace bitstream { void testSpartan3EDevice(const std::string& inDeviceName, 
00035     const boost::filesystem::path& inWorkingPath); }
00036 
00037     /// \brief Spartan3E bitstream.
00038     class Spartan3E : public SpartanBitstream {
00039         friend class torc::bitstream::bitstream::Spartan3EUnitTest;
00040         friend class torc::bitstream::bitstream::Spartan3EFarUnitTest;
00041         friend void torc::bitstream::bitstream::testSpartan3EDevice(const std::string& inDeviceName, 
00042             const boost::filesystem::path& inWorkingPath);
00043     protected:
00044     // typedefs
00045         /// \brief Imported type name.
00046         typedef boost::uint32_t uint32_t;
00047     public:
00048     // enumerations
00049         //
00050         /// \brief Configuration register enumeration.
00051         /// \see configuration registers: XAPP452, v1.1, June 25, 2008, Table 1.
00052         enum ERegister { eRegisterCRC = 0, eRegisterFAR, eRegisterFDRI, eRegisterFDRO, 
00053             eRegisterCMD, eRegisterCTL, eRegisterMASK, eRegisterSTAT, eRegisterLOUT, eRegisterCOR, 
00054             eRegisterMFWR, eRegisterFLR, eRegisterIDCODE = 14, eRegisterCount };
00055         //
00056         /// \brief Configuration command enumeration for eRegisterCMD.
00057         /// \see CMD register commands: XAPP452, v1.1, June 25, 2008, Table 2.
00058         enum ECommand { eCommandNULL = 0, eCommandWCFG, eCommandMFWR, eCommandLFRM, eCommandRCFG, 
00059             eCommandSTART, eCommandRCAP, eCommandRCRC, eCommandAGHIGH, eCommandSWITCH, 
00060             eCommandGRESTORE, eCommandSHUTDOWN, eCommandGCAPTURE, eCommandDESYNCH, eCommandCount };
00061         //
00062         /// \brief Frame Address Register subfields.
00063         /// \see Frame Address Register Description: XAPP452, v1.1, June 25, 2008, Figure 2. 
00064         enum EFar {
00065             eFarMaskColumn =    0x06000000,     eFarShiftColumn =   25,
00066             eFarMaskMajor =     0x01fe0000,     eFarShiftMajor  =   17,
00067             eFarMaskMinor =     0x0001fe00,     eFarShiftMinor  =    9
00068         };
00069         //
00070         /// \brief Frame Address Register top and bottom constants.
00071         enum EFarTopBottom { eFarTop = 0, eFarBottom = 1 };
00072         /// \brief Frame Address Register block type constants.
00073         enum EFarBlockType { eFarBlockType0 = 0, eFarBlockType1, eFarBlockType2, eFarBlockType3, 
00074             eFarBlockType4, eFarBlockType5, eFarBlockType6, eFarBlockType7, eFarBlockTypeCount };
00075         /// \brief Major column types.
00076         /// \details These are defined and used for internal purposes only, and are not derived 
00077         ///     from any Xilinx documentation.
00078         enum EColumnType { eColumnTypeEmpty = 0, eColumnTypeBram, eColumnTypeBramInt, eColumnTypeClb,
00079              eColumnTypeClock, eColumnTypeClockLL, eColumnTypeTerm, eColumnTypeIob, eColumnTypeCount };
00080     protected:
00081     // members
00082 //      /// \brief Configuration controller registers.
00083 //      uint32_t mRegister[eRegisterCount];
00084         /// \brief Packet type names.
00085         static const char* sPacketTypeName[ePacketTypeCount];
00086         /// \brief Packet opcode names.
00087         static const char* sOpcodeName[eOpcodeCount];
00088         /// \brief Configuration register names.
00089         static const char* sRegisterName[eRegisterCount];
00090         /// \brief Configuration command names.
00091         static const char* sCommandName[eCommandCount];
00092         /// \brief Configuration Options Register (COR) subfields.
00093         static const Subfield sCOR[];
00094         /// \brief Status Register (STAT) subfields.
00095         static const Subfield sSTAT[];
00096         /// \brief Control Register (CTL) subfields.
00097         static const Subfield sCTL[];
00098         /// \brief Control Mask Register (MASK) subfields.
00099         static const Subfield sMASK[];
00100     public:
00101     // constructors
00102         /// \brief Basic constructor.
00103         Spartan3E(void) : SpartanBitstream() {
00104 //          for(int i = 0; i < eRegisterCount; i++) mRegister[i] = 0;
00105             // initialize the column type widths for this family
00106             mColumnDefs.resize(eColumnTypeCount);
00107             mColumnDefs[eColumnTypeEmpty]   = ColumnDef("Empty",    0,  0,  0,  0,  0,  0,  0,  0);
00108             mColumnDefs[eColumnTypeBram]    = ColumnDef("Bram",     0, 76,  0,  0,  0,  0,  0,  0);
00109             mColumnDefs[eColumnTypeBramInt] = ColumnDef("BramInt",  0,  0, 19,  0,  0,  0,  0,  0);
00110             mColumnDefs[eColumnTypeClb]     = ColumnDef("Clb",     19,  0,  0,  0,  0,  0,  0,  0);
00111             mColumnDefs[eColumnTypeClock]   = ColumnDef("Clock",    3,  0,  0,  0,  0,  0,  0,  0);
00112             mColumnDefs[eColumnTypeClockLL] = ColumnDef("ClockLL",  4,  0,  0,  0,  0,  0,  0,  0);
00113             mColumnDefs[eColumnTypeIob]     = ColumnDef("Iob",     19,  0,  0,  0,  0,  0,  0,  0);
00114             mColumnDefs[eColumnTypeTerm]    = ColumnDef("Term",     2,  0,  0,  0,  0,  0,  0,  0);
00115             // map type type names to column types
00116             mTileTypeNameToColumnType["BRAMSITE2"]      = eColumnTypeBram;
00117             mTileTypeNameToColumnType["BRAM3_SMALL"]    = eColumnTypeBramInt;
00118             mTileTypeNameToColumnType["CENTER_SMALL"]   = eColumnTypeClb;
00119             mTileTypeNameToColumnType["CLKV"]           = eColumnTypeClock;
00120             mTileTypeNameToColumnType["CLKV_LL"]        = eColumnTypeClockLL;
00121             mTileTypeNameToColumnType["LIOIS"]          = eColumnTypeIob;
00122             mTileTypeNameToColumnType["RIOIS"]          = eColumnTypeIob;
00123             mTileTypeNameToColumnType["LTERM"]          = eColumnTypeTerm;
00124             mTileTypeNameToColumnType["RTERM"]          = eColumnTypeTerm;
00125         }
00126     // functions
00127         /// \brief Return the masked value for a subfield of the specified register.
00128         static uint32_t makeSubfield(ERegister inRegister, const std::string& inSubfield, 
00129             const std::string& inSetting);
00130     // functions
00131         /// \brief Initialize the device information.
00132         virtual void initializeDeviceInfo(const std::string& inDeviceName);
00133         /// \brief Initialize the maps between frame indexes and frame addresses.
00134         /// \detail This is generally only useful for internal purposes.
00135         virtual void initializeFrameMaps(void);
00136     // inserters
00137         /// \brief Insert the bitstream header into an output stream.
00138         friend std::ostream& operator<< (std::ostream& os, const Spartan3E& rhs);
00139     // inner classes
00140         class FrameAddress {
00141         protected:
00142             void assign(uint32_t inAddress) {
00143                 mColumn = (inAddress & eFarMaskColumn) >> eFarShiftColumn;
00144                 mMajor = (inAddress & eFarMaskMajor) >> eFarShiftMajor;
00145                 mMinor = (inAddress & eFarMaskMinor) >> eFarShiftMinor;
00146             }
00147         public:
00148             FrameAddress(void) : mColumn(0), mMajor(0), mMinor(0) {}
00149             FrameAddress(uint32_t inColumn, uint32_t inMajor, uint32_t inMinor) : 
00150                 mColumn(inColumn), mMajor(inMajor), mMinor(inMinor) {}
00151             FrameAddress(uint32_t inAddress) { assign(inAddress); }
00152             uint32_t mColumn;
00153             uint32_t mMajor;
00154             uint32_t mMinor;
00155             bool operator== (const FrameAddress& rhs) const {
00156                 return  mColumn == rhs.mColumn && mMajor == rhs.mMajor && mMinor == rhs.mMinor;
00157             }
00158             bool operator< (const FrameAddress& rhs) const {
00159                 int diffColumn = mColumn - rhs.mColumn;
00160                 if(diffColumn) return diffColumn < 0;
00161                 int diffMajor = mMajor - rhs.mMajor;
00162                 if(diffMajor) return diffMajor < 0;
00163                 return mMinor < rhs.mMinor;
00164             }
00165         };
00166     // accessors
00167         virtual uint32_t getFrameLength(void) const {
00168             using namespace torc::common;
00169             // lengths obtained directly from bitstream Frame Length Register
00170             switch(mDevice) {
00171                 case eXC3S100E: return 49;
00172                 case eXC3S250E: return 73;
00173                 case eXC3S500E: return 97;
00174                 case eXC3S1200E: return 125;
00175                 case eXC3S1600E: return 157;
00176                 default: return 0;
00177             }
00178         }
00179     protected:
00180     // typedefs
00181         /// \brief Map from frame index to frame address.
00182         typedef std::map<uint32_t, Spartan3E::FrameAddress> FrameIndexToAddress;
00183         /// \brief Map from frame address to frame index.
00184         typedef std::map<Spartan3E::FrameAddress, uint32_t> FrameAddressToIndex;
00185         /// \brief Array of vectors to store frame indexes of each block type
00186         typedef std::vector<uint32_t> ColumnIndexVector;
00187 
00188     // members
00189         /// \brief Map of frame indexes to frame addresses.
00190         FrameIndexToAddress mFrameIndexToAddress;
00191         /// \brief Map of frame addressee to frame indexes.
00192         FrameAddressToIndex mFrameAddressToIndex;
00193         /// \brief Vector to store frame indexes of XDL columns.
00194         ColumnIndexVector mBitColumnIndexes [Spartan3E::eFarBlockTypeCount];
00195         /// \brief Vector to store frame indexes of Bitstream columns.
00196         ColumnIndexVector mXdlColumnIndexes [Spartan3E::eFarBlockTypeCount];
00197     };
00198 
00199 } // namespace bitstream
00200 } // namespace torc
00201 
00202 #endif // TORC_BITSTREAM_SPARTAN3E_HPP