|Publication number||US7626861 B1|
|Application number||US 12/343,417|
|Publication date||1 Dec 2009|
|Priority date||30 Aug 2005|
|Also published as||US7474559|
|Publication number||12343417, 343417, US 7626861 B1, US 7626861B1, US-B1-7626861, US7626861 B1, US7626861B1|
|Inventors||Shankar Lakkapragada, Jose M. Marquez, Mark Men Bon Ng|
|Original Assignee||Xilinx, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (9), Non-Patent Citations (12), Referenced by (13), Classifications (10), Legal Events (2)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present application is related to integrated circuits, and more particularly, to a method of and circuit for employing memory cells of an integrated circuit having programmable logic.
A programmable logic device (PLD) is an integrated circuit (IC) that is designed to be user-programmable so that users may implement logic designs of their choices. One type of PLD is the Complex Programmable Logic Device, or CPLD. A CPLD includes two or more “function blocks” connected together and to input/output (I/O) resources by an interconnect switch matrix. Each function block of the CPLD includes a two-level AND/OR structure similar to that used in a Programmable Logic Array (PLA) or a Programmable Array Logic (PAL) device. In some CPLDs, configuration data is stored on-chip in non-volatile memory, then downloaded to volatile memory as part of an initial configuration sequence.
Another type of PLD is a field programmable gate array (FPGA). In a typical FPGA, an array of configurable logic blocks (CLBs) is coupled to programmable input/output blocks (IOBs). The CLBs and IOBs are interconnected by a hierarchy of programmable routing resources. These CLBs, IOBs, and programmable routing resources are customized by loading a configuration bitstream, typically from off-chip memory, into configuration memory cells of the FPGA. For both of these types of programmable logic devices, the functionality of the device is controlled by configuration data bits of a configuration bitstream provided to the device for that purpose. The configuration data bits may be stored in volatile memory (e.g., static memory or SRAM cells, as in FPGAs and some CPLDs), in non-volatile memory (e.g., FLASH memory, as in some CPLDs), or in any other type of memory cell.
PLDs also have different “modes” depending on the operations being performed on them. A specific protocol allows a programmable logic device to enter into the appropriate mode. Typical PLDs have internal blocks of configuration memory which specify how each of the programmable cells will emulate the user's logic. During a “program” mode, a configuration bitstream is provided to non-volatile memory, such as a read-only memory (ROM) (e.g., a programmable ROM (PROM), an erasable PROM (EPROM), an electrically erasable PROM (EEPROM)) either external or internal to the programmable logic device. Each address is typically accessed by specifying its row and column addresses. During system power up of a “startup” mode, the configuration bits are successively loaded from the non-volatile memory into static random access memory (SRAM) configuration latches of a configuration logic block. At the end of this start-up phase, the PLD is now specialized to the user's design, and the PLD enters into “user” mode as part of its normal operation. Once in “user” mode, some resources of the PLD such as logic blocks, routing resources, block RAMs, distributed RAM and I/O pins are made available to the user.
However, the internal configuration memory cells of conventional devices having programmable logic are not made available to end-users. That is, conventional devices do not provide direct access to these internal configuration memory cells of the device during a user mode. In some applications where a programmable logic device has no user-available RAM, a separate memory chip is used for scratchpad memory, which is a temporary memory for storing data generated during a user mode of operation. For example, while FPGAs typically have on-chip block RAM or distributed RAM, conventional CPLDs typically do not have these resources, and circuit designers instead rely on RAM external to the CPLD.
Further, circuits implemented by different customers using PLDs are usually unique. Because PLDs are not design specific and may be used with any design, the configuration memory which is loaded with configuration data will vary based upon the user's circuit design. Therefore, even if a user knows that a given circuit design will not use all of the available memory, and particularly configuration memory, there is no way of telling which configuration memory elements will not be used or will only be partially used before a circuit design is implemented in a PLD.
Accordingly, there is a need for a circuit for and method of employing memory cells of a programmable logic device which make greater use of unused memory cells.
A method of employing memory cells of an integrated circuit is disclosed. The method comprises steps of storing data in a plurality of memory cells of a configuration memory of the integrated circuit; selecting unused memory cells of the configuration memory for use as a scratchpad memory; providing access to the unused memory cells of the configuration memory; and enabling use of the unused memory cells of the configuration memory in a user mode as scratchpad memory. According to one embodiment of the invention, a plurality of input/output ports of the integrated circuit is coupled to a plurality of test ports coupled to the configuration memory to enable use of the unused memory cells.
An integrated circuit is also disclosed. The integrated circuit comprises a plurality of configurable logic blocks, wherein each configurable logic block comprises a configuration memory for storing configuration data. An input/output port is provided for receiving the configuration data to be stored in a first portion of the plurality of memory cells of a configurable logic block. Finally, an unused portion of the plurality of memory cells of a configurable logic block is used as scratchpad memory for storing temporary data. The unused portion of memory cells may comprise memory cells of a random access memory or a read only memory.
Finally, a circuit employing an integrated circuit having memory is also disclosed. The circuit comprises a programmable logic device having a configuration memory comprising a plurality of memory cells for storing configuration data; and an external circuit coupled to the programmable logic device. The external circuit couples data to be stored in unused memory cells of a configuration memory. The external circuit may be, for example, a separate integrated circuit or device on a circuit board, where access to the configuration memory of the programmable logic device eliminates the need for a separate memory device on the circuit board.
Turning first to
The circuit of
Turning now to
The function blocks are connected together and to input/output blocks 212 by a programmable interconnection array 214. The programmable interconnection array includes many multiplexer circuits 216, each including several Programmable Interconnection Points (PIPs) 218. In each multiplexer circuit 216, typically only one PIP 218 is enabled. The enabled PIP selects one of the many input signals provided to the interconnection array, and the selected input signal is provided as the output signal from the multiplexer circuit 216. Further information on CPLDs may be found, for example, in U.S. Pat. No. 6,466,049 B1 by Sholeh Diba et al., issued Oct. 15, 2002, which is hereby incorporated herein by reference.
Turning now to
To program an integrated circuit having programmable logic, designers use PROM programmers or program by way of the Test Access Port (TAP) of the JTAG ports. The TAP comprises four dedicated pins including: the TMS pin (for tracking the controller state), the TCK pin (for receiving the JTAG test clock), the TDI pin (for receiving serial data) and the TDO pin (for outputting serial data) to support all mandatory JTAG instructions. The device also extends the JTAG architecture to implement many of the optional instructions for in-system programming (ISP) as will be described below. These extensions allow cell programming, erasure and verification. As can be seen in
According to one aspect of the invention, read and write operations may be performed by way of the JTAG ports. At some stage in the running of the circuit implemented in programmable logic, a write operation may need to be performed at a given address (e.g., for RAMs) to store data in scratchpad memory. The device is placed in the appropriate ISP mode for writing, and uses the data on the data and address pins to write to memory. When the writing is finished, a JTAG instruction is issued to return the device to the user mode. At another stage in the running of the circuit, a read operation may need to be performed at an address. Once again, the device is placed in the appropriate ISP mode for reading, and uses the address pins to read from the memory. Upon completion, the data is made available to the data pins and a JTAG instruction is issued to return the device to the user mode. The JTAG control signals may be generated externally to the integrated circuit if an external device is using configuration memory cells of the integrated circuit as scratchpad memory. Alternatively, the JTAG signals may be generated internal to the integrated circuit to enable reading from or writing to unused configuration memory cells.
In order to perform a serial write operation of specified data to a specified address, the appropriate JTAG instructions are shifted in to the TDI pin to enable the ISP serial programming mode. The appropriate JTAG instructions are then shifted in to program the configuration memory. All address bits are provided to the pins designated for addressing. Data is then shifted in to program the device, and the ISP mode is exited. Similarly, in order to perform a serial read operation from a specified address, the appropriate JTAG instructions are shifted in to the TDI pin to enable the ISP serial programming mode. The appropriate JTAG instructions are shifted in to read from the configuration memory. All address bits are provided to the pins designated for addressing, and data is serially read from the TDO pin before the ISP mode is exited.
Similarly, it is possible to perform parallel read and write operations by way of the JTAG ports. In order to perform a parallel write operation of specified data to a specified address, the appropriate JTAG instructions are shifted in to the TDI pin to enable ISP parallel programming mode. All address bits are provided to the pins designated for addressing. Data is supplied at the appropriate data pins, and the necessary strobe signals are supplied to write the data to the specified address. The ISP mode is then exited. Similarly, a parallel read operation from a specified address may also be performed by shifting in the appropriate JTAG instructions to the TDI pin to enable ISP parallel programming mode. All address bits are provided to the pins designated for addressing. The necessary strobe signals are supplied to read data from the specified address. Finally, parallel data is read at the appropriate data pins, and the ISP mode is exited.
Turning now to
In some FPGAs, each programmable tile includes a programmable interconnect element (INT 411) having standardized connections to and from a corresponding interconnect element in each adjacent tile. Therefore, the programmable interconnect elements taken together implement the programmable interconnect structure for the illustrated FPGA. The programmable interconnect element (INT 411) also includes the connections to and from the programmable logic element within the same tile, as shown by the examples included at the top of
For example, a CLB 402 may include a configurable logic element (CLE 412) that may be programmed to implement user logic plus a single programmable interconnect element (INT 411). A BRAM 403 may include a BRAM logic element (BRL 413) in addition to one or more programmable interconnect elements. Typically, the number of interconnect elements included in a tile depends on the height of the tile. In the pictured embodiment, a BRAM tile has the same height as four CLBs, but other numbers (e.g., five) may also be used. A DSP tile 406 may include a DSP logic element (DSPL 414) in addition to an appropriate number of programmable interconnect elements. An IOB 404 may include, for example, two instances of an input/output logic element (IOL 415) in addition to one instance of the programmable interconnect element (INT 411). As will be clear to those of skill in the art, the actual I/O pads 416 connected, for example, to the I/O logic element 415 are manufactured using metal layered above the various illustrated logic blocks, and typically are not confined to the area of the input/output logic element 415. Similar to the circuit of FIG. 3, the I/O pads 416 are coupled to JTAG ports associated with the configurable logic block, enabling an external device to use unused configuration memory cells of the configuration logic blocks or other programmable tiles as scratchpad memory, in addition to other available memory such as the BRAMs 403. However, it should be understood that internal logic of the FPGA (e.g., logic implemented in one of the CLBs) may also be coupled to the JTAG pins of the configuration logic block to enable the use of unused configuration memory cells as scratchpad memory.
In the pictured embodiment, a columnar area near the center of the die (shown shaded in
Turning now to
Because there are a number of different types of unused memory cells of the various programmable logic devices described above, the control circuit will also preferably make available unused memory according to a predetermined order. For example, if there is available volatile memory on the integrated circuit external to the configurable logic, the unused memory elements of the volatile memory, such as the BRAMs 403, should be used first before unused memory cells of the configurable logic blocks. The unused memory cells of a configurable logic block may then be used. A hierarchy for allocating unused memory cells of a configurable logic block for scratchpad memory may be employed. For example, configuration memory cells may be used first. Then, if additional memory cells are required, memory implemented by a function generator of an unused configurable logic block would be used first before using unused memory cells of memory implemented by a function generator of a used configurable logic block. For unused memory implemented in a configuration logic block, a lookup table (LUT) memory of a block 504, such as function generator 506 implemented as a look-up table, would preferably be used first, followed by an SRAM. Generally, flash memory or EEPROM memory may be used last. According to the hierarchy described above, memory cells are grouped according to their access speeds, for example from fastest to slowest. Other factors such as bandwidth or proximity may also be used in determining a hierarchy of memory cells. However, if scratchpad memory capacity is a concern, all of the function generators of the blocks 504 may be implemented as SRAMs.
Turning now to
Further, in addition to using configuration memory of an FPGA, such as memory elements M1-M7, for scratchpad memory as shown, logic that is part of the programmable logic and is implemented as memory (such as a function generator implemented as an SRAM or a lookup table memory as described above) may also be used as scratchpad memory. Each function generator may function in any of several modes depending upon the data in the configuration memory elements. When in lookup table mode, each LUT has four data input signals IN3-IN0 that are supplied by the programmable interconnect element 411 via input multiplexers, which will be described in more detail in reference to
Turning now to
Finally, turning to
According to a typical user software design flow employing the circuits and methods described above, the user instantiates memory (RAM32×2, ROM64×1, etc.) primitives in a design along with other design logic. The user may specify constraints to assign the logic to specific memory addresses, either scratchpad or user RAM. Finally, based on constraints, logic requirements and memory requirements, a software program enabling unused configuration memory to be used as scratchpad memory partitions the design into the appropriate areas. In some cases it may be desirable to use unused configuration memory, rather than block RAM external to the configuration logic block, as scratchpad memory. Once finished, the software creates a report file. Accordingly, software may aid the user to exploit these newly available memory by transparently deciding which memory areas (user RAM blocks or internal scratchpad memory) should be used for parts of the design; providing mechanisms (i.e., constraints) which let users specify that parts of the design should reside in scratchpad memory or user RAM blocks; and preventing use of configuration areas as scratchpad memory which are already being used by the programmable logic device via design rule checks (e.g., provide reports enumerating what configuration memory resources may be set aside as scratchpad memory).
The methods and circuits for employing memory cells of a programmable logic device described above have a number of advantages. For example, the methods and circuits provide cost efficiency. That is, the circuits described above may replace one or more memory devices otherwise required on a circuit board with a programmable logic device having reconfigured on-chip memory to potentially provide a one-chip solution. By reducing memory chips on a circuit board or system, users may reduce cost and may save on-board real estate. Because for some designs, the configuration memory area of the programmable logic device may not always be fully utilized, the circuits and methods of employing unused memory cells of configuration memory thus makes more efficient use of the available memory space of a programmable logic device. Devices employing the circuits and methods of the present invention are easy to use because software may be used to intelligently and transparently partition the internal configuration areas into configuration logic and user-available memory. Users need only to specify how much and what type(s) of memory they need during their design process. The circuits and methods also provide logic and resource efficiency. In some applications, it may be more desirable to use available on-chip configuration memory rather than logic block resources.
It may therefore be appreciated that the new and novel circuit for and method of employing a memory in a configurable logic block has been described. It will be appreciated by those skilled in the art that numerous alternatives and equivalents will be seen to exist which incorporate the disclosed invention. As a result, the invention is not to be limited by the foregoing embodiments, but only by the following claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US6466049||14 Sep 2000||15 Oct 2002||Xilinx, Inc.||Clock enable control circuit for flip flops|
|US6487710||30 Jun 2000||26 Nov 2002||Xilinx, Inc.||Method and apparatus for assigning PLD signal routes to input signals having different voltage requirements|
|US6560665||14 May 1999||6 May 2003||Xilinx Inc.||Embedding firmware for a microprocessor with configuration data for a field programmable gate array|
|US6983441 *||28 Jun 2002||3 Jan 2006||Texas Instruments Incorporated||Embedding a JTAG host controller into an FPGA design|
|US6995584||29 Oct 2004||7 Feb 2006||Xilinx, Inc.||Power-up and enable control circuits for interconnection arrays in programmable logic devices|
|US7375549 *||9 Feb 2006||20 May 2008||Lattice Semiconductor Corporation||Reconfiguration of programmable logic devices|
|US7505331 *||23 Nov 2005||17 Mar 2009||Altera Corporation||Programmable logic device with differential communications support|
|US20010054129||30 Apr 2001||20 Dec 2001||Wouters Cornelis Bernardus Aloysius||Method, system and computer program|
|US20020184436||31 Dec 2001||5 Dec 2002||Samsung Electronics Co., Ltd.||Flash memory management method|
|1||Altera Corporation; "Serial Configuration Devices Advanced Features", 2 pages, available from Altera Corporation, 101 Innovation Drive, San Jose, California 95134, USA or at http://altera.com/products/devices/serialcfg/features/scu-adv- features.html.|
|2||Khu, Arthur, et al., "Using Xilinx XCF02S/XCF04S JTAG PROMs for Data Storage Applications", XAPP544 (v1.0) Jul. 20, 2005, pp. 1-6, Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|3||Rosch, Winn L., Hardware Bible, Mar. 2003, 6th edition, Chapter 16, Section 3, 11 pages.|
|4||U.S. Appl. No. 11/169,462, filed Jun. 29, 2005, Khu, Arthur H., Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|5||U.S. Appl. No. 11/216,299, filed Aug. 5, 2005, Lakkapragada, Shankar et al., Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|6||Xilinx, Inc., "CoolRunner XPLA3 CPLD", Product Specification, DS012, Apr. 8, 2005, (v2.1), pp. 1-12, available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|7||Xilinx, Inc., "CoolRunner-II CPLD Family", Product Specification, DS090, Jun. 28, 2005, (v2.5), pp. 1-14, available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|8||Xilinx, Inc., "Spartan-3E FPGA Family: Complete Data Sheet", Product Specification, DS312, Mar. 21, 2005, (v1.1) pp. 1-193, available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|9||Xilinx, Inc., "Virtex-II Platform FPGAs: Complete Data Sheet", Product Specification, DS031, Mar. 1, 2005, (v3.4), pp. 1-318, available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|10||Xilinx, Inc., "XC9500 In-System Programmable CPLD Family", Product Specification, DS063, Apr. 15, 2005, (v5.3), pp. 1-16, available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|11||Xilinx, Inc., "XC9500XL High-Performance CPLD Family Data Sheet", Product Specification, DS054, Jul. 15, 2005, (v2.0), pp. 1-17, available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|12||Xilinx, Inc., "XC9500XV Family High-Performance CPLD", Product Specification, DSO49, Apr. 15, 2005, (v2.2), pp. 1-18 available from Xilinx, Inc., 2100 Logic Drive, San Jose, CA 95124.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7787314 *||11 Sep 2008||31 Aug 2010||Altera Corporation||Dynamic real-time delay characterization and configuration|
|US8006012 *||23 Aug 2011||Princeton Technology Corporation||Data storage system|
|US8339154 *||17 Mar 2010||25 Dec 2012||Thales||Built-in line test method|
|US8446170 *||3 May 2012||21 May 2013||Actel Corporation||FPGA RAM blocks optimized for use as register files|
|US8570065 *||3 Apr 2012||29 Oct 2013||Semiconductor Energy Laboratory Co., Ltd.||Programmable LSI|
|US9218505||31 Jan 2013||22 Dec 2015||Xilinx, Inc.||Programmable integrated circuit with DPA-resistant decryption|
|US20080320239 *||5 Feb 2008||25 Dec 2008||Princeton Technology Corporation||Data storage system|
|US20100061166 *||11 Mar 2010||Altera Corporation||Dynamic real-time delay characterization and configuration|
|US20110084723 *||14 Apr 2011||Thales||Built-in Line Test Method|
|US20120268164 *||25 Oct 2012||Semiconductor Energy Laboratory Co., Ltd.||Programmable lsi|
|US20120280711 *||3 May 2012||8 Nov 2012||Actel Corporation||Fpga ram blocks optimized for use as register files|
|US20120326747 *||18 Apr 2012||27 Dec 2012||Samsung Electronics Co., Ltd.||Reconfigurable logic device|
|CN102818987B *||3 Jul 2012||24 Dec 2014||航天科工防御技术研究试验中心||Multiple real-time reconfiguration adaptor used in test of field-programmable gate array device|
|U.S. Classification||365/185.08, 326/44, 365/185.05, 326/39|
|International Classification||H03K19/177, G11C16/20|
|Cooperative Classification||G11C16/08, H03K19/1776|
|European Classification||H03K19/177H3, G11C16/08|
|23 Dec 2008||AS||Assignment|
Owner name: XILINX, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:LAKKAPRAGADA, SHANKAR;MARQUEZ, JOSE M.;NG, MARK MEN BON;REEL/FRAME:022025/0465
Effective date: 20050830
|14 Mar 2013||FPAY||Fee payment|
Year of fee payment: 4