|Publication number||US7254800 B1|
|Application number||US 10/787,683|
|Publication date||Aug 7, 2007|
|Filing date||Feb 26, 2004|
|Priority date||Feb 26, 2004|
|Also published as||US7979826|
|Publication number||10787683, 787683, US 7254800 B1, US 7254800B1, US-B1-7254800, US7254800 B1, US7254800B1|
|Inventors||Stephen M. Trimberger|
|Original Assignee||Xilinx, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (17), Non-Patent Citations (3), Referenced by (18), Classifications (5), Legal Events (3)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The invention relates to Programmable Logic Devices (PLDs). More particularly, the invention relates to methods of detecting and correcting transmission errors in PLD configuration bitstreams.
Programmable logic devices (PLDs) are a well-known type of integrated circuit that can be programmed to perform specified logic functions. One type of PLD, the field programmable gate array (FPGA), typically includes an array of configurable logic blocks (CLBs) and programmable input/output blocks (IOBs). The CLBs and IOBs are interconnected by a programmable interconnect structure. Some FPGAs also include additional logic blocks with special purposes (e.g., clock management circuits such as delay lock loops (DLLs), block RAM, processors, and so forth).
The interconnect structure, CLBs, IOBs, and other logic blocks are typically programmed by loading a stream of configuration data (bitstream) into internal configuration memory cells that define how the logic blocks and interconnect are configured. The configuration data can be read from memory (e.g., an external PROM) or written into the FPGA by an external device. The collective states of the individual memory cells then determine the function of the FPGA.
Security of the configuration bitstream is a concern for some FPGA users. While configuration is the process of writing the configuration data to the FPGA, “readback” is the process of reading the configuration data from the configured FPGA. A bitstream read from a previously-configured FPGA could be used to configure other, similar, FPGAs, by persons other than those responsible for the original design. Alternatively, the bitstream could be used for reverse engineering a design, i.e., to obtain sensitive information about the design. Therefore, FPGAs typically include an option for disabling readback of the configuration bitstream, or for allowing readback only once (to allow confirmation that the device was configured properly), and then disabling the readback function. Thus, for most PLDs, bitstreams are safe from piracy (e.g., unauthorized duplication or analysis of the bitstream) once the PLD has been successfully configured.
However, a bitstream can potentially still be copied by an unauthorized person prior to (or during) the loading of the bitstream into the PLD. Both to prevent an intercepted bitstream from being used to configure a PLD, and to prevent reverse engineering of the design from the intercepted bitstream, some PLD providers provide bitstream encryption and decryption. In other words, the data in the bitstream is encrypted in such a way as to make it extremely difficult to extract information about the design implemented by the bitstream. The bitstream is then decrypted by decryption circuitry included in the PLD to regenerate the original (unencrypted) bitstream during the configuration process for the PLD. Without the decryption key, the bitstream cannot be decrypted, and the PLD cannot be successfully configured using the pirated bitstream.
Some currently available FPGAs offer both a CRC (cyclic redundancy check) feature and encryption/decryption capability. The CRC feature checks for transmission errors, while the encryption/decryption feature provides a strong barrier to bitstream piracy. One FPGA providing both CRC and encryption/decryption is the Virtex™-II FPGA available from Xilinx, Inc. The Xilinx Virtex-II FPGA is described in detail in pages 33-75 of the “Virtex-II Platform FPGA Handbook”, published in December, 2000 and available from Xilinx, Inc., 2100 Logic Drive, San Jose, Calif. 95124. The encryption/decryption feature of the Virtex-II FPGA is described briefly on page 75, and more fully on pages 307-310, of the same publication. Pages 33-75 and 307-310 of the Virtex-II Platform FPGA Handbook are incorporated herein by reference.
In step 102, the original bitstream is encrypted using one or more user-supplied encryption keys 103. For example, three 56-bit DES (Data Encryption Standard) keys can be supplied to enable the well-known triple-DES encryption method. This step produces an encrypted bitstream 104. In the encrypted bitstream, the original CRC value can be encrypted or can remain unencrypted.
In step 105, the encrypted bitstream 104 is loaded into the target PLD. The PLD includes decryption circuitry. In addition, the user must supply one or more user-supplied decryption keys, which are typically the same as the encryption keys (i.e., element 103). For example, in a Virtex-II FPGA the decryption keys are loaded into the FPGA via a JTAG port, and the key data is maintained using an external battery. If the external battery fails or is disconnected, the key data is cleared from the key memory.
In step 106, the encrypted bitstream is decrypted by the decryption circuitry using the user-supplied decryption keys, providing a decrypted bitstream 107. The decrypted bitstream 107 is loaded into the PLD, i.e., stored in the configuration memory of the PLD (step 108). However, the PLD is not yet functional, as the power-up sequence has not been initiated.
In step 109, a new CRC value 110 is generated from the decrypted bitstream. In step 111, the original CRC value 112 is extracted from the decrypted bitstream. Thus, the original CRC value 112 represents the bitstream as it should be, and the new CRC value 110 represents the bitstream as actually used to configure the PLD.
Note that the steps illustrated in
In step 113, the new and original CRC values are compared. If no errors have occurred in transit, the two CRC values should be the same. If the two CRC values match (decision step 114), the startup procedure for the configured PLD is performed (step 115), and the PLD begins to function according to the programmed design. If the new CRC value does not match the original CRC value (decision step 114), the startup process for the PLD is disabled (step 116), and the programmed design never becomes functional. The readback function can also be disabled in this situation. Thus, if the encrypted bitstream is subject to a transmission error (or to deliberate tampering) prior to step 105, the new and original CRC values do not match, and the design can be neither used nor studied.
If desired, a new bitstream download can be manually or automatically initiated (see arrow 117) after the detection of a CRC error. This procedure is commonly followed when CRC errors are assumed to be the result of transmission errors, e.g., when bitstream tampering is not a concern.
In theory, a decryption key could be discovered by using a pirated bitstream to repeatedly configure a PLD. Every possible combination of bits can be tried as the decryption key, until one combination results in a functional, configured PLD. However, since each test requires at least a few milliseconds, and there are typically at least 56 bits in the decryption key, this is a very time-consuming process. Even greater security is provided by using encryption/decryption methods such as the triple-DES method. When three 56-bit keys are used for encryption, as in the triple-DES method, it would take many years of effort to “break the code” for a single design. Therefore, the use of triple-DES encryption/decryption methods (or other highly secure methods) is highly desirable in situations where extreme security is required.
However, no matter what encryption/decryption algorithm is used, the configuration of a PLD with an encrypted bitstream requires the presence of the decryption key. Therefore, if reconfiguration of the PLD is enabled, the decryption key is generally stored in a special key memory in the PLD. In these situations, the configured, functional PLD remains, at least in theory, subject to reconfiguration by a “hostile” bitstream, e.g., by a bitstream created by an unauthorized person attempting to obtain sensitive information about the design.
Therefore, it is desirable to provide methods of detecting unauthorized bitstreams presented to a PLD in an attempt to reconfigure the device, and preventing the use of such bitstreams to obtain sensitive information. It is further desirable to detect and correct transmission errors in PLD configuration bitstreams. It is yet further desirable to differentiate between transmission errors and unauthorized attempts to access sensitive information by altering a configuration bitstream, thereby allowing a single PLD to address both of these two situations.
A first aspect of the invention provides methods of securing a programmable logic device (PLD) when an intrusion attempt is detected. According to some embodiments, the invention provides methods of erasing sensitive data from the PLD when an attack is detected. According to other embodiments, the invention provides methods of disabling startup and reconfiguration of the PLD when an attack is detected. For example, when an attempt is made to configure the PLD with an unauthorized bitstream, a decryption key stored on the PLD can be erased, or decryption logic in the PLD can be otherwise disabled.
In some embodiments, an incorrect cyclic redundancy check (CRC) value during configuration is interpreted as an attack, while in other embodiments a counter permits a predetermined number of failed configuration attempts before assuming an attack and erasing the sensitive data. In some embodiments, an error correction procedure is performed on the bitstream after receiving the bitstream and before generating a new CRC value. This procedure prevents most transmission errors from being incorrectly interpreted as an attack.
In some embodiments, an attack is assumed when no CRC value is received within a predetermined number of clock cycles after receipt of a configuration bitstream. In other embodiments, an attempt to operate the PLD outside normal operating ranges is interpreted as an attack.
A second aspect of the invention provides methods of providing error correction in configuration bitstreams. These methods can be used, for example, to correct transmission errors while continuing to circumvent unauthorized attacks as described above. While any error correction method can be used, in one embodiment a Hamming code is applied to each instruction in the configuration bitstream, while a product code is applied to configuration data. Thus, the higher overhead required for a Hamming code applies to only a few words in the bitstream. The instructions are corrected on receipt of the word that includes the Hamming code, so the instructions are executed correctly even if a transmission error has occurred. However, configuration data can be stored in the configuration memory without correction. With a product code, the exact location of an erroneous bit is not known until the end of the transmission, when a parity word is received. At this time, the PLD can go back and correct erroneous bits in the configuration data prior to enabling the newly loaded design.
The present invention is illustrated by way of example, and not by way of limitation, in the following figures.
In the following description, numerous specific details are set forth to provide a more thorough understanding of the present invention. However, it will be apparent to one skilled in the art that the present invention can be practiced without these specific details.
Unencrypted configuration bitstreams are inherently relatively secure, simply because of the complexity of the configuration bitstreams in use today. A configuration bitstream for a modern PLD can include millions of bits. Each bit in the bitstream can, for example, form a portion of a configuration instruction, provide data to be stored in a single configuration memory cell in the PLD, remain unused, form a portion of a CRC value, or serve some other purpose. Identifying the target configuration memory cell, for example, for a single bit in the bitstream is no easy task.
However, when the motivation is strong enough, an unauthorized person might be able to create a “map” showing the correspondence between configuration data bits in the bitstream and either locations or functions in the PLD targeted by the bitstream. Therefore, encrypted bitstreams are often used in sensitive applications. In an encrypted bitstream, there is no one-to-one correspondence between bit values and configuration memory cells, or between bit values and functions within the PLD. The value of each bit in the encrypted bitstream depends on the values of many bits in the unencrypted bitstream. Hence, little or no information can be gained about a design by studying the encrypted bitstream.
Further, altering a single bit in the encrypted bitstream and then loading the bitstream into a PLD causes a CRC error, and the PLD never becomes functional. This is true even if the would-be pirate has somehow obtained the decryption key and loaded the key into the target PLD, or has obtained the use of a PLD that already stores the decryption key (e.g., a PLD already part of a functioning system in which reconfiguration is enabled by the presence of the key).
Therefore, encrypted configuration bitstreams are very secure, particularly when the triple-DES encryption/decryption technique described in the Background section is used. However, even with an encrypted bitstream, it might be possible to obtain information about a PLD design, given sufficient time and motivation, using the method illustrated in
At step 203, the altered bitstream is loaded into the target PLD using the PLD's decryption circuitry and the required decryption key. (The term “target PLD” is used herein to indicate a PLD consistent with the configuration bitstream of interest.) On extremely rare occasions, particularly if the CRC value includes a small number of bits, the altered configuration bitstream might have the same CRC value as the original bitstream. If this is the case (decision step 204), an attempt can be made to read the target data (step 206). For example, the would-be pirate can look for the sensitive RAM data at the aforementioned I/O pads. Of course, the changes made to the encrypted bitstream are unlikely to have made the desired changes to the design. (Although the general vicinity of the target bits in the bitstream might be known, the encryption algorithm ensures that no simple correlation exists between the target bits and the bits of the encrypted bitstream.) If the data is read successfully (e.g., if the RAM data is present at the I/O pads), then the process is complete (“End”, 208).
The likelihood of reaching step 208 is very small. Much more likely, for example, is that when the attempt is made to configure the PLD it will be discovered that the CRC value of the altered bitstream is different from that of the original bitstream. However, the location of the CRC value within the bitstream is generally known (e.g., at the end of the bitstream), and a CRC value has a finite number of bits. For example, many existing PLDs have a CRC value that includes 16 bits. Thus, if the configuration step is unsuccessful (step 204), the CRC value in the bitstream can be altered to another of the 2**16 (two to the sixteenth power) possible values (step 205), and the bitstream can be downloaded again to the PLD (step 203) using the new CRC value.
For example, if the original CRC value is sent to the PLD “in the clear” (in unencrypted format), an attacker can modify the original CRC value, iterating through all possible values until the matching CRC value for the modified bitstream is found. If the original CRC value is not available to the attacker (e.g., if the original CRC value is encrypted, or is stored with the decryption key on the PLD), the attacker can modify other bits in the bitstream that do not affect the portion of the design targeted by the attack. These other modified bits will cause the new CRC to change. If sufficient time and resources are available, eventually the correct CRC value will be obtained, and the PLD will configure successfully (step 204). Clearly, the amount of time required to obtain the correct CRC value is greatly affected by the number of bits in the CRC value.
Another major hurdle for the would-be pirate is attempting to come up with an alteration to the encrypted data that will produce the desired internal connections within the PLD. This process would be one of trial and error. For each altered bitstream, the correct CRC value would first have to be found. Then, each successful altered bitstream would have to be tested to see if the desired effect appeared in the design (step 207). If not, a new alteration to the bitstream would be attempted (return to step 202).
In some PLDs, it might be possible to discover a simple alteration to the bitstream that would enable the readback feature. In these PLDs, once this simple alteration was found, the entire decrypted bitstream could be easily obtained. Hence, unauthorized persons might well attempt to locate a modification to the bitstream that would enable readback. Therefore, some PLDs (e.g., the Xilinx Virtex-II FPGAs referenced above) include a feature whereby whenever decryption is enabled, the readback capability is automatically disabled in hardware. Hence, no alteration to an encrypted bitstream can enable readback in these devices. When this protective feature is present, bitstream modifications that could endanger secure data are likely to be much more extensive and much more difficult to discover.
Given the almost random nature of the alterations to the bitstream and the need to try very large numbers of CRC values for each altered bitstream, the probability of success in this endeavor is very low without the investment of large amounts of resources and several years of time. A 16-bit CRC value would typically require tens of thousands of guesses before the correct value is obtained. To successfully guess dozens of bits of configuration data in addition to the CRC value would typically require millions or billions of trials. However, as previously stated, some applications for PLDs are so sensitive that every possible precaution should be taken in the interests of security. Further, performing billions of trials is within the technological capabilities of bitstream pirates today. Therefore, encryption keys are typically 168 bits in length, requiring on the order of 2**168 trials to guess correctly.
The procedure shown in
In some embodiments, some or all of the configuration data in the PLD is erased along with the decryption key.
One way in which the decryption key and configuration data might be erased is by reusing existing circuitry that already erases these data. For example, the aforementioned Virtex-II devices include an internal oscillator that is used to clear the decryption key and configuration data when the device enters “key access mode” (e.g., prior to loading a decryption key). A straightforward method of erasing the decryption key and configuration data is to place the device into key access mode whenever an attack is detected.
To successfully configure the PLD with an unauthorized bitstream, it would be necessary to guess correctly on the first attempt not only what change to the bitstream is necessary to achieve the desired purpose, but also what CRC value will enable the configuration of the device. To have any chance of configuring the PLD with a modified bitstream would require access to the decryption key, or access to another system including another operational, reconfigurable PLD storing the decryption key. Clearly, if an attacker were required to purchase millions or billions of systems in an attempt to pirate the bitstream, launching the attack using the described methods would be completely impractical. Therefore, the method of
In other embodiments, a single erroneous CRC value is not considered sufficient evidence of an attack. For example, a transmission error can cause the receipt of an erroneous CRC value. Therefore, in some embodiments, a failed-bitstream counter keeps track of the number of failed attempts to load a configuration bitstream. Only after a predetermined number of failed attempts is an attack presumed to be taking place. This approach is similar in some respects to the well-known approach taken at automatic teller machines (ATMs), for example, which allow the entry of several incorrect personal identification numbers (PINs) before retaining an ATM card. In some embodiments, a setting in the PLD memory (e.g., memory powered by a battery backup or non-volatile memory) is used to store a maximum allowable number N of failed bitstreams. In some embodiments, the number of permitted failed attempts can optionally be set to a value of “unlimited”, which setting can be used in non-sensitive applications.
Embodiments allowing multiple configuration attempts, however, can provide less security than some other embodiments, because the counter could probably be reset simply by cycling power to the PLD. For example, if a third failed attempt erases the decryption key, an attacker could make two attempts, cycle power to clear the failed-bitstream counter, and then try again. However, if cycling the power to the failed-bitstream counter also erases the decryption key and the configuration data, this objection is overcome.
In some embodiments, the count of failed attempts is stored in a non-volatile memory on the PLD, along with the decryption key. In these embodiments, the PLD can track break-in attempts even when the power is shut down and restored. In one PLD with one-time-programmable memory, the PLD programs one memory cell each time a failed attempt is detected. In another embodiment, attacks are tracked probabilistically, by programming a non-volatile memory cell with a probability of 25% (for example) for every failed attack. When the last memory cell available for failed-bitstream programming has been programmed, the PLD clears the decryption key from the PLD memory.
In some embodiments, an attack is assumed whenever multiple bit errors are found in widely-separated parts of the bitstream.
In other embodiments, an attack is assumed whenever an attempt is detected to operate the PLD outside normal operating ranges for the PLD. For example, over-temperature operation, under-temperature operation, an abnormally slow internal clock, abnormal variations in the power supply voltage, power near or exceeding the allowable limits, and a variable internal clock could be detected and interpreted as an attack. Each of these conditions is sometimes used to conduct attacks on presently-available FPGAs, for example.
Returning now to
Element 504 provides an end point for the process of
As previously mentioned with respect to
The method illustrated in
The method illustrated in
Various methods of error correction can be used to insert ECC codes into the bitstream, and to perform the error correction procedure as shown, for example, in step 721 (
Note that the use of error correcting codes is consistent with the above-described methods of detecting and circumventing unauthorized attacks. An error correcting procedure typically detects and corrects single-bit flips within a group of bits (e.g., within a bitstream word). After error correction has been applied, the bitstream is the same as it was prior to the bit flip. If a would-be pirate flips a single bit in the bitstream in an attempt to obtain sensitive information about the design, the ECC procedure simply corrects the bit to its original value, and the resulting design is unchanged. No sensitive information can be derived by following this procedure. However, changes to the bitstream that are not corrected by the ECC procedure (e.g., multi-bit flips in some ECC procedures) are still interpreted as attacks.
To perform error correction on a configuration bitstream, one option is to treat the PLD bitstream like any other transmitted data. For example, desirable characteristics of the selected error correcting code include low overhead (i.e., only a small increase in the number of bits in the bitstream) and the ability to correct the types of transmission errors most likely to occur in PLD bitstreams, such as single-bit errors as opposed to multi-bit errors. One code possessing these characteristics might be, for example, a “product code”. In a product code, the data can be thought of as composed of an JxK array of bits (J words of K bits each). In a simple product code, parity is computed on each word, generating a new word of K+1 bits. A cumulative word-wise parity is then calculated using the new Jx(K+1) array, producing one extra parity word that is the exclusive OR function (XOR) of all of the modified words. Therefore, the overhead is one bit per word plus one additional word, or J+(K+1). Assuming a very large number of 32-bit words, for example, the overhead is about 1/32, or about 3 percent.
When a product code is used, if a one-bit transmission error occurs, the error is detected and identified as an error using the parity bit at the end of the word in which the erroneous bit resides. The bit position of the parity word (added to the end of the bitstream) is also flipped. Therefore, it is clear which bit is in error, and the erroneous bit is easily corrected by flipping the value of the bit.
The drawback of applying the product code method to PLD bitstreams is that a bitstream includes not just data, but also instructions. When the product code method is used, errors are not corrected until after the parity word at the end of the data stream has been received. When the bitstream includes instructions as to how subsequent words in the bitstream are to be interpreted, how many subsequent words are affected by an instruction, and/or where and when the data is to be stored, as in modern PLDs, these instructions are followed on receipt, e.g., before the error correction has been applied. Thus, errors in the instruction word can cause configuration errors even when product code error correction is applied to the bitstream.
For example, if an instruction means “store this number of subsequent data words in configuration memory at this address”, and one of the bits comprising the instruction is in error, the configuration data will not be stored, or will be stored incorrectly. Storing the entire bitstream somewhere in the PLD, and then running the error correction procedure on the bitstream prior to loading the data into configuration memory, would overcome this drawback. However, this is not really a practical option. Not only does the amount of data in the bitstream typically vary (with an indicator of the amount of data being included in the bitstream), but temporarily storing a bitstream potentially including several million bits would require an impracticably large amount of additional on-chip memory.
Another option is to encode each word in the configuration bitstream using its own error correcting code, e.g., a Hamming code. Hamming error correcting codes are well-known in the relevant arts. The use of Hamming codes makes error correction in PLD bitstreams a relatively simple matter. However, the overhead is high. A standard Hamming code contains log(i)+1 bits, where “i” is the total number of bits in each coded word (including the Hamming code). Therefore, a 32-bit word including a Hamming code typically includes six bits of ECC, giving an overhead value of about 6/32, or 19%.
However, note that this type of error coverage is much more valuable when applied to instruction words in the bitstream than when applied to configuration data words. If an error occurs in a configuration data word, the PLD can read back the errant configuration frame and flip the erroneous bit. Therefore, a combined error correction scheme can be implemented in which a Hamming code is used on instruction words, which need to be corrected “on the fly”, and a separate product code is used on configuration data words.
For efficiency, the configuration data word size can be made equal to the configuration frame size for the PLD. This approach simplifies the error correction procedure, as described below. The instruction words can be the same size as the configuration data words, or a different size. If the product code correction scheme is not applied to the instruction words, as in some embodiments, there is no need to make the instruction words the same size as the configuration data words.
The combined Hamming/product code method can be implemented as follows, for example. A Hamming code is added to each instruction word in the bitstream. Each instruction word is typically followed by a string of many configuration data words. One parity bit is added to each configuration data word in the string, i.e., per configuration frame, as described above in relation to the product code error correction method. Thus, a one-bit error in a configuration data word shows up immediately in the parity bit for that word. However, it is not known which bit in the word is incorrect until the final parity word (at the end of the string) is received. Therefore, when an erroneous word is detected during configuration, the address of the corresponding configuration frame is stored. When the parity word is received, the location of the erroneous bit within the configuration frame is determined and the erroneous bit is flipped at the previously stored address. For example, the configuration frame can be read from the stored address and exclusive ORed (XORed) with the parity word (assuming even parity), and the altered frame of data can be written back into the configuration memory at the same address.
In some embodiments, the bitstream is divided into two or more streams of data, e.g., each preceded by an instruction word and followed by a parity word. For example, a bitstream can include many different blocks of data, with instructions that they be treated in different ways (i.e., write to a single address, write to several addresses (multi-frame write), and so forth). For example, a bitstream might include an instruction to write to the frame data register (FDR) of the PLD, where the instruction includes a LENGTH value, and follow the instruction word with a long string of configuration data words. The length of the string corresponds to the LENGTH value previously specified. A bitstream can include several such commands. In this example, each portion of the bitstream that includes an instruction to write to the FDR and the configuration data to be written can have its own parity word. (For additional information on FDRs and instructions included in configuration bitstream, see, for example, the “Virtex Series Configuration Architecture User Guide, XAPP151 v1.6”, published Mar. 24, 2003 by Xilinx, Inc., which is incorporated herein by reference.)
In a PLD having a configuration frame of 1312 bits, for example, the overhead of the “mixed mode” or “two tier” error correcting code described above is about 1/1312 (less than 0.1%), because the bitstream consists mostly of data rather than instructions. Nevertheless, the critical transmission errors (e.g., the instruction errors) are corrected immediately on receipt by the PLD, and the less critical errors (e.g., the data errors) can be corrected after receipt of the parity frame, as described above.
In some embodiments, the ECC overhead is reduced even further. A typical instruction word size in a PLD bitstream is 32 bits. However, instructions often do not require 32 bits, so some of these bits are unused. These unused bits can be used to store an error code, e.g., a Hamming code for the instruction word. For example, a 32-bit instruction word could include 27 bits providing the information relevant to the instruction, and a 5-bit Hamming code. In some embodiments the Hamming code is accommodated in instruction words by reducing the number of bits available for the LENGTH value.
In some embodiments, the bitstream includes a string of bitstream words, and in step 904 an erroneous bit in one bitstream word is corrected prior to receipt of a following bitstream word. This approach is particularly helpful when the erroneous word is an instruction word including instructions directing action to be taken in regard to the next word or words in the bitstream. In some embodiments, the erroneous bit is not corrected until after the entire bitstream is received by the PLD. This approach might apply, for example, in embodiments in which a single product code is applied to the entire bitstream.
In some embodiments, the bitstream received in step 902 is encrypted. Therefore, the bitstream must be decrypted prior to configuring the PLD in step 905. This decryption step can be performed either before or after the error correction procedure, as shown (for example) in
Element 1001 (“Begin”) provides a starting point for the method. In step 1002, an instruction word from the configuration bitstream is received, e.g., at a configuration port of a PLD. In step 1003, an error correcting code (ECC) is retrieved from the instruction word. This ECC can be, for example, a Hamming code. However, other types of error correcting codes can also be used. In step 1004, the value of at least one bit in the instruction word is corrected based on the ECC retrieved in step 1003. In step 1005, the instruction corresponding to the corrected instruction word is executed.
Optionally, a different kind of error correcting code can included in the bitstream for the configuration data words, as shown in
Element 1101 (“Begin”) provides a starting point for the method. In step 1102, a configuration bitstream is generated that implements a design in the PLD. If desired, this bitstream can include a CRC value (as in bitstream 101 of
The error correcting code added in step 1103 can be, for example, a Hamming code or a product code. However, other types of error correcting codes can also be used. In some embodiments, step 1103 comprises adding a Hamming code to each instruction word in the bitstream. In some embodiments, a Hamming code is added to each word, including both instruction words and configuration data words. In some embodiments, e.g., embodiments in which a product code is used, each word to which the product code is applied has the same size, which is the same as a configuration frame size for the PLD. This approach facilitates correction of each configuration data word after the parity word for the coded portion of the bitstream has been received.
As described above, in some embodiments different types of codes are applied to different portions of the bitstream. For example, a high overhead code such as a Hamming code can be applied to instruction words, while a low overhead code such as a product code is applied to configuration data words. Note also that the “mixed mode” or “two tier” error correcting methods described herein can also be applied to data streams other than configuration bitstreams. For virtually any data stream that includes both instruction words and data words, the use of different ECC methods for the instruction words and data words can reduce overall ECC overhead while providing “on the fly” error correction for the instruction words in the transmitted data.
Those having skill in the relevant arts of the invention will now perceive various modifications and additions that can be made as a result of the disclosure herein. For example, the above text describes the circuits and methods of the invention in the context of field programmable gate arrays (FPGAs). However, the circuits of the invention can also be implemented in other programmable logic devices (PLDs). Accordingly, all such modifications and additions are deemed to be within the scope of the invention, which is to be limited only by the appended claims and their equivalents.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4336611 *||Dec 3, 1979||Jun 22, 1982||Honeywell Information Systems Inc.||Error correction apparatus and method|
|US5457408 *||Nov 23, 1994||Oct 10, 1995||At&T Corp.||Method and apparatus for verifying whether a bitstream received by a field programmable gate array (FPGA) is intended for that FPGA|
|US6366117 *||Nov 28, 2000||Apr 2, 2002||Xilinx, Inc.||Nonvolatile/battery-backed key in PLD|
|US6429682 *||May 25, 2001||Aug 6, 2002||Xilinx, Inc.||Configuration bus interface circuit for FPGAs|
|US6590929 *||Jun 8, 1999||Jul 8, 2003||International Business Machines Corporation||Method and system for run-time logic verification of operations in digital systems|
|US6901502 *||Dec 5, 2001||May 31, 2005||Matsushita Electric Industrial Co., Ltd.||Integrated circuit with CPU and FPGA for reserved instructions execution with configuration diagnosis|
|US7073117 *||Feb 13, 2003||Jul 4, 2006||Ciena Corporation||Method and apparatus for generating bit errors in a forward error correction (FEC) system to estimate power dissipation characteristics of the system|
|US20020166091 *||Mar 25, 2002||Nov 7, 2002||Kidorf Howard D.||Concatenated forward error correction decoder|
|US20030070134 *||Aug 16, 2002||Apr 10, 2003||Raanan Ivry||System and method for encoding and decoding data utilizing modified reed-solomon codes|
|US20030237038 *||Jan 22, 2003||Dec 25, 2003||Cole Robert M.||System and method for forward error correction|
|US20040025105 *||Aug 1, 2002||Feb 5, 2004||Lattice Semiconductor Corporation||CRC calculation system for a packet arriving on an n-byte wide bus and a method of calculation thereof|
|US20040034828 *||Dec 26, 2002||Feb 19, 2004||Texas Instruments Incorporated||Hardware-efficient low density parity check code for digital communications|
|US20040131058 *||Jul 23, 2003||Jul 8, 2004||Ali Ghiasi||Multiple high-speed bit stream interface circuit|
|US20040247238 *||Jul 24, 2002||Dec 9, 2004||Georgia Tech Research Corporation||Spatially resolved equalization and forward error correction for multimode fiber links|
|US20050144584 *||Dec 29, 2003||Jun 30, 2005||Tzu-Shern Chen||Programmable logic module and upgrade method thereof|
|US20060013118 *||Jun 20, 2003||Jan 19, 2006||Takashi Ishida||Optical disc, optical disc recording device, optical disc recording method|
|US20060013333 *||Oct 16, 2003||Jan 19, 2006||The Directv Group, Inc.||Maximizing power and spectral efficiencies for layered and conventional modulations|
|1||U.S. Appl. No. 09/797,138, filed Feb. 28, 2001, Trimberger.|
|2||Xilinx, Inc.; "Virtex-II Platform FPGA Handbook"; published in Dec. 2000; available from Xilinx, Inc., 2100 Logic Drive, San Jose, California 95124; pp. 33-75.|
|3||Xilinx, Inc.; XAPP151 (v1.6); Virtex Series Configuration Architecture User Guide:; Mar. 24, 2003; available from Xilinx, Inc., 2100 Logic Drive, San Jose, California 95124; pp. 1-45.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7895509||Aug 8, 2008||Feb 22, 2011||Xilinx, Inc.||Error checking parity and syndrome of a block of data with relocated parity bits|
|US7937647 *||Jul 27, 2007||May 3, 2011||Actel Corporation||Error-detecting and correcting FPGA architecture|
|US8024688 *||Dec 12, 2008||Sep 20, 2011||Xilinx, Inc.||Deterring reverse engineering|
|US8146028||Nov 19, 2008||Mar 27, 2012||Xilinx, Inc.||Duplicate design flow for mitigation of soft errors in IC operation|
|US8245102 *||Aug 8, 2008||Aug 14, 2012||Xilinx, Inc.||Error checking parity and syndrome of a block of data with relocated parity bits|
|US8301988||Jan 12, 2011||Oct 30, 2012||Xilinx, Inc.||Error checking parity and syndrome of a block of data with relocated parity bits|
|US8370703 *||Jul 9, 2010||Feb 5, 2013||Samsung Electronics Co., Ltd.||Information encoding method, information decoding method, recording/reproducing apparatus, and information storage medium|
|US8415974||Mar 9, 2011||Apr 9, 2013||Xilinx, Inc.||Methods and circuits enabling dynamic reconfiguration|
|US8516339||Apr 1, 2011||Aug 20, 2013||Xilinx, Inc.||Method of and circuit for correcting adjacent bit errors in a memory|
|US8539254 *||Jun 1, 2010||Sep 17, 2013||Xilinx, Inc.||Method and integrated circuit for protecting against differential power analysis attacks|
|US8566616 *||Sep 10, 2004||Oct 22, 2013||Altera Corporation||Method and apparatus for protecting designs in SRAM-based programmable logic devices and the like|
|US8909941||Mar 31, 2011||Dec 9, 2014||Xilinx, Inc.||Programmable integrated circuit and a method of enabling the detection of tampering with data provided to a programmable integrated circuit|
|US8966253 *||Jun 1, 2010||Feb 24, 2015||Xilinx, Inc.||Method and apparatus for authenticating a programmable device bitstream|
|US8972833||Jun 6, 2012||Mar 3, 2015||Xilinx, Inc.||Encoding and decoding of information using a block code matrix|
|US8972835||Jun 6, 2012||Mar 3, 2015||Xilinx, Inc.||Encoding and decoding of information using a block code matrix|
|US20090031194 *||Jul 27, 2007||Jan 29, 2009||Actel Corporation||Error-detecting and correcting fpga architecture|
|US20110010604 *||Jul 9, 2010||Jan 13, 2011||Samsung Electronics Co., Ltd.||Information encoding method, information decoding method, recording/reproducing apparatus, and information storage medium|
|US20150100793 *||Sep 15, 2014||Apr 9, 2015||Microsemi SoC Corporation||Method of Improving FPGA Security Using Authorization Codes|
|International Classification||G06F17/50, H03K17/693|
|Feb 26, 2004||AS||Assignment|
Owner name: XILINX, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:TRIMBERGER, STEPHEN M.;REEL/FRAME:015037/0164
Effective date: 20040225
|Feb 7, 2011||FPAY||Fee payment|
Year of fee payment: 4
|Feb 9, 2015||FPAY||Fee payment|
Year of fee payment: 8