Built-in self repair for memory

A method for repairing a memory includes running a built-in self-test of the memory to find faulty bits. A first repair result using a redundant row block is calculated. A second repair result using a redundant column block is calculated. The first repair result and the second repair result are compared. A repair method using either the redundant row block or the redundant column block is selected. The memory is repaired by replacing a row block having at least one faulty bit with the redundant row block or replacing a column block having at least one faulty bit with the redundant column block.

BACKGROUND

Some conventional memory repair methods have low success rates, thus resulting in limited memory yield. Row-first repair methods (replacing faulty rows first) and/or column-first repair methods (replacing faulty columns first) are relatively simple and have relatively less timing penalties. However, those methods cannot repair some defective memories that can be repaired by other redundancy arrangements. On the other hand, complex repair methods (e.g., using a row-first repair method, then replacing it with a column-first repair method if not successful, etc.) incur expensive testing costs and need longer run times to finish the repair. Accordingly, new circuits and methods are desired to solve the above problems.

DETAILED DESCRIPTION

FIG. 1is a flowchart of a built-in self-repair (BISR) method for a memory according to some embodiments. At step102, a built-in self-test (BIST) executes to check the memory under testing. The BIST checks all memory cells (bits) in the memory and if any faulty bit (error) is found, creates a map (or index) of faulty bits, such as shown inFIG. 2. At step104, if there is no error, the process is finished. If there is any error, the process continues to step106.

At step106, the BISR method determines if the faulty bits can be repaired. If the faulty bits cannot be repaired, the process is finished. If the faulty bits can be repaired, voting variables are calculated at step108before making a decision to select a row-first repair or a column-first repair method. The voting variables are used to estimate possible repair results using each method, and the details of exemplary voting variables are described below forFIG. 2.

Based on the calculated voting variables, one of the row-first repair or the column-first repair methods is selected at steps110or112. For example, row-first repair and column-first repair methods are compared to select the best repair method. In some embodiments, a first faulty bit, e.g., a faulty bit located at the lowest row/column number, is considered first. Then all potentially remaining faulty bits, after a row repair or a column repair that includes the first faulty bit, are calculated. And the calculated faulty bits are used to calculate the weight of each solution by voting mechanism and compared to select one repair method.

For example, the number of all the remaining faulty bits are compared for the row repair method and the column repair method, each including the first faulty bit. A method with the least number of faulty bits remaining is selected. If both methods result in the same number of remaining faulty bits, then a default method is chosen (e.g., user defined, available redundant row/column, or randomly selected, etc.).

At step110, a row first repair method is selected to replace the row including at least some of the faulty bits. At step112, a column first repair method is selected to replace the column including at least some of the faulty bits. After a row first or a column first repair method is selected at either step110or112, then the faulty bits in the memory are repaired using the selected method at step114. If there are no more redundant (spare) columns and rows to replace the faulty column or row, the memory cannot be repaired.

The memory repair is performed by replacing either the row or the column containing the faulty bits by a redundant (spare) row or column, if available. In some embodiments, a pair of rows or columns (or any number of rows or columns) can be replaced as a unit, e.g., a row block or a column block (that includes at least one row or column). After the repair is finished, the process returns to step102and executes the BIST again to check the memory and find the remaining faulty bits, if they still exist. This process continues until the remaining faulty bits are all repaired or the memory cannot be repaired (the memory may be discarded). More details of exemplary methods according toFIG. 1are described below, including a pseudo code.

FIG. 2is a schematic diagram showing a memory200with faulty bits (circles) after the first run of a built-in self-test (BIST) for the BISR method inFIG. 1according to some embodiments. The exemplary memory200includes a left half204and a right half206, divided at the input/output (TO) connections208. Redundant columns for the left half204and right half206can be separately implemented, e.g., to the left edge and right edge of the memory200.

Depending on the memory's redundant (spare) row and column implementations, a pair of rows and/or a pair of columns can be treated as a replacement unit, and in this case the row pair (row block) or column pair (column block) that includes faulty bits are repaired as one unit. In the memory200, two rows are paired as a unit for replacement purposes, thus regarded as one row block.

After finding the faulty bits (circles) in the memory at step102using BIST, voting variables as defined below are calculated, e.g., by using register counters. A first faulty bit202(black circle), e.g., a faulty bit located at the lowest row/column number, is considered first.

The voting variables are: (1) Related Row Count (RRowCnt), which is the total number of faulty bits in the same row (block) of the first faulty bit202; (2) Violation Row Count (VRowCnt), which is the number of faulty bits outside the same row (block) of the first faulty bit202; (3) Related Column Count (RColCnt1, RColCnt2), which is the total number of faulty bits in the same column (block) of the first faulty bit202, and there are two counts in this case, RColCnt1for the left half204and RColCnt2for the right half206of the memory respectively; (4) Violation Column Count (VColCnt1, VColCnt2), which is the number of faulty bits outside the column (block) of the first faulty bit202, and there are two counts in this case, VColCnt1for the left half204, and VColCnt2for the right half206of the memory respectively; (5) Violation Column Count in Row (VColCnt_in Row), which is the number of faulty bits outside the column (blocks) but inside the same row (block) of the first faulty bit202.

For the memory200, it is assumed that redundant columns for the left half204are used only for the left half204, and redundant columns for the right half206are used only for the right half206. The variables described above are calculated from the perspective of the first faulty bit202as follows: (1) RRowCnt is 3, because there are 3 faulty bits in the same row block of the first faulty bit202; (2) VRowCnt is 4, because there are 4 faulty bits outside the same row block as the first faulty bit202; (3) RColCnt1is 2, because there are 2 faulty bits in the same column block of the first faulty bit202, and RColCnt2is 0, because the first faulty bit202is located in the left half204; (4) VColCnt1is 2, because there are 2 faulty bits outside the same column block of the first faulty bit202on the left half204, and VColCnt2is 0, because the first faulty bit202is located in the left half204; (5) VColCnt_in Row is 2, because there are 2 faulty bits in the same row block and outside the column block of the first faulty bit202.

The decision of which repair methods, e.g., row-first repair or column-first repair, are used is determined by the following pseudo code process in one embodiment.

If VColCnt_inRow == 0 {There is no other violation (faulty) column block inside therow block of the first faulty bit.}If (RColCnt1+RColCnt2) == RRowCnt {There is a single faulty bit or multiplefaulty bits present in the column block inside the first faulty bit row block.}If VRowCnt < (VColCnt1+VColCnt2) {The repair result will have less faulty bitsremaining by row replacement than column replacement}Row repairIf VRowCnt > (VColCnt1+VColCnt2) {The repair result will have more faultybits remaining by row replacement than column replacement}Column repairIf (RRowCnt > 1) {There are more than one faulty bits in the first faulty bitcolumn block.}If row first repair method is default then row repair; else column repair{Follow default repair method}Else {There is a single faulty bit present.}If row first repair method is default then row repair; else column repair{Follow default repair method}Else If RRowCnt < (RColCnt1+RColCnt2) {The repair result will correct less faultybits by row replacement than column replacement}Column repairElse {The repair result will correct more faulty bits by row replacement than columnreplacement.}Row repairElse {There is another column block with at least one faulty bit inside the first faulty bitrow block.}Row repair

The above pseudo code first determines whether there is any other faulty column block (i.e., other than the first faulty bit column block) inside the first faulty bit row block and if so, the first faulty bit row block is repaired. If not, then the code compares whether the row repair or the column repair including the first faulty bit can repair more faulty bits and selects the repair method that will fix more faulty bits. If it is determined during the process that both repair methods can fix the same number of faulty bits, then a default priority method is selected, e.g., a row-first repair, or a column-first repair method.

The above pseudo code is one exemplary implementation, and there can be many variations, e.g., if there is at least one faulty bit outside the first faulty bit column block, the row repair or column repair options can be compared to select a method that repairs more faulty bits, instead of selecting the row repair method. Simplicity, speed, repair success rate, and efficiency of the BISR among other criteria can be considered when implementing embodiments of the BISR method.

Based on the above description of the pseudo code and the values of calculated voting variables forFIG. 2(e.g., VColCnt_in Row is 2), a row repair method is selected in step110after the first run of BIST at step102, and the first repair is carried out at step114. After the first repair, the BISR process returns to BIST at step102for a second run.

FIG. 3is a schematic diagram showing the memory with faulty bits after the second run of the built-in self-test (BIST) for the BISR method of inFIG. 1according to some embodiments. The memory300shows that the row block including the first faulty bit202inFIG. 2is replaced by a redundant (spare) row block302(e.g., through rearrangement of electrical connections, not necessarily by physical replacement). The second run of BIST shows the new first faulty bit304and other remaining faulty bits after the first repair, and the voting variables are updated as the following: (1) RRowCnt=1; (2) VRowCnt=3; (3) RColCnt1=0; RColCnt2=1; (4) VColCnt1=0; VColCnt2=1; (5) VColCnt_in Row=0.

Based on the voting variable values, a column repair is selected at step112to replace the column block306that includes the new first faulty bit304, since VRowCnt>(VColCnt1+VColCnt2) from the pseudo code above. After the second repair is carried out at step114, the BISR process returns to BIST at step102for a third run, and after a third repair, returns for a fourth run, etc., until all faulty bits are repaired, or the memory runs out of redundant rows and columns and cannot repair the memory.

According to exemplary memory repair tests, one embodiment of the disclosed BISR method successfully repaired a faulty memory in about 131 ms, using 2 redundant columns and 8 redundant rows. In comparison, a conventional column first method repaired the same faulty memory in about 125 ms, using 3 redundant columns and 8 redundant rows, while an exemplary complex repair method repaired in 713 ms, using 3 redundant columns and 8 redundant rows. Other conventional methods, e.g., a row-only method, a column-only method, and a row-first method failed to repair the same faulty memory. Thus, the exemplary BISR method was the most efficient in using the least number of redundant rows and columns, and also was much faster than the tested complex repair method.

Regarding the disclosed BISR method's test repair speed of 131 ms compared to the 125 ms of the conventional column first method, the time measurement resolution of the automatic testing equipment used was not high enough to precisely determine the time differences, and another test with more precise time measurement was performed. In this test, the column first method's inter-die repair time was 1.103 ms, using 3 columns and 4 rows. In comparison, the disclosed BISR method's inter-die repair time was 0.966 ms, using 2 columns and 3 rows. Therefore, the disclosed BISR method's repair time was less than the tested column-first method.

Because the disclosed BISR method repairs the test memory while many prior known repair methods fail to repair it, the disclosed BISR method provides a higher repair rate. Also, the disclosed BISR method's run time is less than the tested complex repair method, row-first repair method, and column-first repair method, and also is more efficient than other methods because it uses less redundant (spare) rows and/or columns for the repair.

According to some embodiments, a method for repairing a memory includes running a built-in self test of the memory to find faulty bits. A first repair result using a redundant row block is calculated. A second repair result using a redundant column block is calculated. The first repair result and the second repair result are compared. A repair method using either the redundant row block or the redundant column block is selected. The memory is repaired by replacing a row block having at least one faulty bit with the redundant row block or replacing a column block having at least one faulty bit with the redundant column block.

According to some embodiments, a memory has a built-in self-repair (BISR) circuit that is capable of performing a set of operations. The set of operations includes: running a built-in self test of the memory to find faulty bits; calculating a first repair result using a redundant row block; calculating a second repair result using a redundant column block; comparing the first repair result and the second repair result; selecting a repair method using either the redundant row block or the redundant column block; and repairing the memory by replacing a row block having at least one faulty bit with the redundant row block or replacing a column block having at least one faulty bit with the redundant column block.

According to some embodiments, a computer-readable storage medium has instructions stored thereon. The instructions, when executed by a processor, cause the processor to perform the operations of: running a built-in self test of the memory to find faulty bits; calculating a first repair result using a redundant row block; calculating a second repair result using a redundant column block; comparing the first repair result and the second repair result; selecting a repair method using either the redundant row block or the redundant column block; and repairing the memory by replacing a row block having at least one faulty bit with the redundant row block or replacing a column block having at least one faulty bit with the redundant column block.

The above method embodiment shows exemplary steps, but they are not necessarily required to be performed in the order shown. Steps may be added, replaced, their order changed, and/or eliminated as appropriate, in accordance with the spirit and scope of embodiments of the disclosure. Embodiments that combine different claims and/or different embodiments are within scope of the disclosure and will be apparent to those skilled in the art after reviewing this disclosure.