FLASH redundancy replacement system and method

By reading the redundant area and main area position lines in parallel, the pointer and self-increase structure can be used to realize cyclic verification and error replacement of the redundant area position lines, which solves the problems of high testing costs and poor accuracy in the existing technology, and improves FLASH redundancy Efficiency and accuracy of replacement.

CN118969048APending Publication Date: 2024-11-15GIANTEC SEMICON LTD INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202410921722.4
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-07-10
Publication Date
2024-11-15

AI Technical Summary

Technical Problem

The prior art has high testing costs, poor accuracy and low efficiency in the FLASH redundant replacement process, making it difficult to take into account both the testing costs and accuracy.

Method used

Multiple Sense Amplifiers (SAs) are used to read the bit lines of the redundant area and the main area in parallel, and the cyclic verification and error replacement of the redundant area bit lines are realized through two pointers and self-increasing structures, reducing test time and ensuring replacement accuracy.

Benefits of technology

Through one traversal detection and replacement, the test time is reduced, the accuracy of redundant replacement is improved, the testing cost is reduced, and the reliability of FLASH is ensured.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118969048A_ABST
    Figure CN118969048A_ABST
Patent Text Reader

Abstract

The invention discloses a FLASH redundancy replacement system and method, and the method comprises the steps: configuring a first pointer rdnaddr as an index pointer of a redundant region bit line, and configuring a second pointer rdnno to point to the redundant region bit line used for replacing a defective bit line; when redundancy replacement is carried out on the FLASH, firstly, a word line to be read is determined, on the same word line, when it is read that a certain bit line of a main area has defects, the bit line, currently pointed by a second pointer rdnno, of a redundancy area is replaced with the defect bit line of the main area, and the second pointer rdnno points to the next bit line of the redundancy area; and reading the next group of bit lines on the current word line, carrying out corresponding replacement behaviors until the current word line is read, and reading the next word line until all the word lines in the main region are read. According to the method, the two pointers and the main area are synchronously detected, in the process that the main area is detected once, the redundant area can be circularly verified, error replacement can be corrected, the test time is shortened, and meanwhile the accuracy of redundant replacement is guaranteed.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present invention relates to the field of memory, and in particular to a FLASH redundancy replacement system and method. Background Art

[0002] Flash memory technology is very complex, and the probability of one or more memory cells being defective during the manufacturing process cannot be ignored. To meet the demand, any large-capacity memory should contain more memory cells than the normal addressable range, called redundant cells, which are used to replace defective cells found during manufacturing. However, the redundant cells themselves may also have defects, so FLASH is usually tested twice, before and after replacement, which greatly increases the testing cost. If only one test is performed, since the FLASH addressing order increases by word line, the quality of the entire redundant bit line can only be determined when the last word line is scanned. Therefore, during most of the scanning process, the quality of the redundant cells is unknown, and it is difficult to guarantee accuracy when directly used for replacement.

[0003] In summary, it is difficult for existing application methods to strike a balance between test cost and accuracy. Summary of the invention

[0004] The purpose of the present invention is to solve the problems of high testing cost, poor accuracy and low efficiency when performing redundant replacement of FLASH.

[0005] To achieve the above object, the present invention discloses a FLASH redundancy replacement system, which is used to replace defective bit lines in a main area with bit lines in a redundant area, comprising:

[0006] Multiple SAs, one of which is used to sequentially read the M+1 bit lines of the redundant area, and the SA of the redundant area reads one bit line of the redundant area each time; the other multiple SAs are used to sequentially read the bit lines of the main area, and the SA of the main area reads multiple bit lines of the main area each time;

[0007] A first pointer rdn_addr, serving as an index pointer for the bit lines in the redundant area, the first pointer rdn_addr circulates among all the bit lines rdn0 to rdnM in the redundant area as SA is read;

[0008] The second pointer rdn_no points to a redundant area bit line used to replace a defective bit line in the main area. The redundant area bit lines pointed to by the second pointer rdn_no increase monotonically from rdn0 to rdnM.

[0009] Preferably, the FLASH redundancy replacement system further comprises: FLAG[M:0][1:0], used to record whether multiple bit lines in the redundant area are used for replacement and whether they are detected as bad, wherein [M:0] represents bit lines rdn0 to rdnM in the redundant area, and [1:0] represents whether they are used for replacement and whether they are detected as bad; LUT[M:0][N:0], representing the error addresses recorded by M+1 bit lines in the redundant area, wherein N=N1+N2-1, [N:0] represents N+1 bits of data, wherein N1 bits of data represent the number of times a defect occurs in the reading, and the number of times required for multiple SAs to complete the reading of the main area bit lines of the same word line is 2 N1 , N2-bit data indicates the address of the main area bit line where the defect occurs, 2 N2 Number of SAs in the primary area.

[0010] Preferably, the FLASH redundant replacement system also includes: a self-increment structure of the second pointer rdn_no, the self-increment structure includes an excluder and a priority encoder, the specific bit line address of the redundant area currently pointed to by the second pointer rdn_no and FLAG[M:0][1:0] are input into the excluder, the excluder determines which redundant bit lines have been used or marked as bad and excludes them based on FLAG[M:0][1:0], and then outputs the target value of rdn_no+1 or rdn_no+2 through the priority encoder, and assigns the target value to the original second pointer rdn_no.

[0011] The second aspect of the present invention discloses a FLASH redundant replacement method. When the above-mentioned FLASH redundant replacement system is used to perform redundant replacement on FLASH, the word line to be read is first determined. On the same word line, when a bit line of the main area is read to be defective, the bit line of the redundant area currently pointed to by the second pointer rdn_no is replaced with the defective bit line of the main area, and the second pointer rdn_no is made to point to the next bit line of the redundant area; then the next group of bit lines on the current word line are read, and corresponding replacement behavior is performed until the current word line is read, and then the next word line is read, until all word lines of the main area are read.

[0012] Preferably, when the second pointer rdn_no points to the last bit line of the redundant area and after another replacement occurs, if a defective bit line of the main area is still read, the replacement process is terminated and the FLASH is judged as a waste.

[0013] Preferably, when the SA of the redundant area detects that a bit line of the redundant area is defective, the bit line of the redundant area is marked as bad; and the second pointer rdn_no is made to skip the bit line marked as bad when it increases monotonically.

[0014] Preferably, after the FLASH completes the redundant replacement, when accepting host access, when the address main_addr to be accessed by the host matches the information recorded in the LUT[N:0], the specific information of the LUT[M:0] can be obtained, and then the FLAG[M:0][1:0] corresponding to the LUT[M:0] can be obtained, so as to know whether the address main_addr to be accessed by the host has been replaced and whether it has been detected as bad.

[0015] Preferably, after the redundant replacement starts, corresponding logical operations are performed according to the results read by multiple SAs each time. During the reading process, if it is found that the number of defective bit lines in the main area is greater than the number of bit lines in the redundant area, the process is ended in advance; otherwise, the process ends until the word lines and bit lines in the main area both reach the maximum value.

[0016] Preferably, the results read by multiple SAs each time are in the form of X+Y. X represents the detection result of the main area, and Y represents the detection result of the redundant area. The detection result is 1 or 0, where 1 means there is a defect and 0 means there is no defect. Different logical operations are performed according to different reading results X+Y, as follows:

[0017] ① The reading result is 1+0: Replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of the main area; and use LUT[rdn_no][N:0] to record the error position, and set FLAG[rdn_no][1] to 1, indicating that the rdn_no has been used for replacement; increment rdn_no according to the self-increment structure.

[0018] ② The reading result is 0+1, and it specifically includes the following situations:

[0019] FLAG[rdn_addr][1]=1 and rdn_addr<rdn_no: Set FLAG[rdn_addr][1] to 0, set FLAG[rdn_addr][0] to 1; and assign LUT[rdn_addr] to LUT[rdn_no], and set FLAG[rdn_no][1] to 1; increment rdn_no according to the self-increment structure.

[0020] FLAG[rdn_addr][1]=0 and rdn_addr<rdn_no: No further operation is required.

[0021] FLAG[rdn_addr][1]=0 and rdn_addr=rdn_no: Set FLAG[rdn_no][0] to 1; increment rdn_no according to the self-increment structure.

[0022] FLAG[rdn_addr][1] = 0 and rdn_addr > rdn_no: Set FLAG[rdn_addr][0] to 1;

[0023] ③ The read result is 1 + 1, and specifically includes the following situations:

[0024] FLAG[rdn_addr][1] = 1 and rdn_addr < rdn_no and not the situation in: Replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of this main area; and use LUT[rdn_no][N:0] to record the error location; make FLAG[rdn_no][1:0] = 2'b10, indicating that rdn_no at this time is used for replacement and not detected as bad; and assign the error address in LUT[rdn_addr] to LUT[rdn_no + 1], make FLAG[rdn_no + 1][1:0] = 2'b10; make FLAG[rdn_addr][1:0] = 2'b01, indicating that rdn_addr at this time is not used for replacement and is detected as bad; finally make rdn_no increment according to the increment structure;

[0025] FLAG[rdn_addr][1] = 0 and rdn_addr < rdn_no and not the situation in: Replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of this main area; and use LUT[rdn_no][N:0] to record the error location, make FLAG[rdn_no][1:0] = 2'b10; finally make rdn_no increment according to the increment structure;

[0026] FLAG[rdn_addr][1] = 0 and rdn_addr = rdn_no and not the situation in: Replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of this main area; use LUT[rdn_no + 1][N:0] to record the error location, make FLAG[rdn_no + 1][1:0] = 2'b10; make FLAG[rdn_addr][1:0] = 2'b01; finally make rdn_no increment according to the increment structure;

[0027] FLAG[rdn_addr][1] = 0 and rdn_addr > rdn_no and not In the case of: the bit line of the redundant area currently pointed to by the second pointer rdn_no is replaced with the defective bit line of the main area; and LUT[rdn_no][N:0] is used to record the error position, and FLAG[rdn_no][1:0]=2'b10; FLAG[rdn_addr][1:0]=2'b01; finally, rdn_no is incremented according to the self-increment structure;

[0028] The current address of the main area 100 has been replaced and the error position is equal to the recorded position; the bit line of the redundant area currently pointed to by the second pointer rdn_no is replaced with the defective bit line of the main area; LUT[mapped_idx] is assigned to LUT[rdn_no], where, since the current address of the main area 100 has been replaced, mapped_idx refers to the Bit line of the redundant area 200 corresponding to the replacement before the current address of the main area 100; FLAG[mapped_idx] = 2'b01; finally, rdn_no is incremented according to the auto-increment structure;

[0029] ④Others: When any situation other than ① to ③ above occurs, the process is stopped and the FLASH is judged to be a waste.

[0030] Compared with the prior art, the present invention has the following advantages and beneficial effects:

[0031] The present invention uses two pointers to perform detection synchronously with the main area. During a detection process of the main area, the redundant area can perform cyclic verification and realize the correction of erroneous replacement, thereby reducing the test time and ensuring the accuracy of redundant replacement.

[0032] In this scheme, only one traversal is required, during which redundant lines of unknown quality may be used, but will eventually be replaced by redundant lines known to be correct. BRIEF DESCRIPTION OF THE DRAWINGS

[0033] Figure 1 Array structure diagram of FLASH according to an embodiment of the present invention;

[0034] Figure 2 A schematic diagram of a pointer to a redundant area according to an embodiment of the present invention;

[0035] Figure 3 A schematic diagram of a self-incrementing structure according to an embodiment of the present invention;

[0036] Figure 4 This is a redundancy replacement flow chart of an embodiment of the present invention. DETAILED DESCRIPTION

[0037] The following will be combined with the embodiments of the present invention Figure 1 to Figure 4, the technical solutions, structural features, objectives achieved and effects in the embodiments of the present invention are described in detail.

[0038] It should be noted that the drawings are in a very simplified form and use non-precise proportions. They are only used to conveniently and clearly assist in explaining the embodiments of the present invention, and are not used to limit the conditions for the implementation of the present invention. Therefore, they have no substantive technical significance. Any structural modification, change in proportional relationship or adjustment of size, without affecting the effects and purposes that can be achieved by the present invention, should still fall within the scope of the technical content disclosed by the present invention.

[0039] It should be noted that, in the present invention, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only the elements explicitly listed, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device.

[0040] The invention discloses a FLASH redundancy replacement system and method, which detects the storage units of the storage array of the FLASH main area (ie the main storage area) in sequence, and uses the storage units of the redundant area to replace the defective storage units of the main area.

[0041] like Figure 1 As shown, the storage array of the main area 100 includes 1024 word lines (abbreviated as WL in the figure) and 8192 bit lines (abbreviated as BL in the figure), forming a two-dimensional matrix, and each intersection represents a storage unit; the redundant area 200 is configured with the same number of word lines (1024) as the main area 100, but the number of bit lines is significantly reduced to 8; the redundant area 200 and the main area 100 share the word line, and the defective bit line of the main area 100 can be directly replaced with the bit line of the redundant area 200 without changing the word line. Therefore, when a defect is detected in a bit line of the main area 100, a complete bit line of the redundant area 200 is used to replace the entire defective bit line.

[0042] Since the number of bit lines in the redundant area 200 is 8, the upper limit of the number of replacements is 8. In other embodiments, other numbers of bit lines in the redundant area 200 may be set, which may be determined based on statistical analysis of yield rate, production cost considerations, and the overall reliability level expected to be achieved.

[0043] In the current redundant replacement method, the word line is read from low to high. When reading the low-order word line, if a bit line is defective, the bit line of the redundant area 200 (the bit line of the redundant area 200 will be referred to as the redundant column hereinafter) is used to replace it. However, at this time, it cannot be determined whether the high-order word line of the redundant column used for replacement is defective. Therefore, as the reading order of the word line increases (from low to high), it is still possible to detect that the redundant column originally used for replacement is a defective redundant column. At this time, a secondary detection and replacement is required, which increases the detection cost.

[0044] To solve the above problems, an embodiment of the present invention discloses a FLASH redundancy replacement system and method, which uses SA (Sense Amplifier) ​​to read FLASH. The more SAs there are, the larger the amount of data read out at one time, but the area cost of the chip also increases accordingly. FLASH requires 128 SAs to read data normally. In order to obtain data in the redundant area 200 and take into account the area cost, 129 SAs are used in the FLASH redundancy replacement system of the present invention, of which 128 SAs are used to read the Bit line of the main area 100 at one time, and the other 1 SA is used to read 8 redundant columns, and the SA in the redundant area reads one redundant column each time.

[0045] The data read out by 129 SAs each time is 128 bits (the result of the Bit line reading of the main area 100) + 1 bit (the result of the redundant column reading). Because there is only one SA in the redundant area 200, it is impossible to select 2 or more redundant columns for replacement. Therefore, only one defective bit line can be read out of the 128 bits of main area data read out each time. If two defective bit lines appear, FAIL DIE is directly determined, indicating that the quality of the FLASH does not meet the standard. However, for general FLASH, the probability of 2 or more defects in the 128 bits of data in the main area 100 read out each time is much lower than the situation of no defects or 1 bit defects. Therefore, setting one SA to read the redundant area 200 will not have a significant impact on the yield of the FLASH.

[0046] When using 129 SAs to read FLASH, it is generally read from WL0 to WL1023 in sequence (i.e., from the low word line to the high word line), or, in other embodiments, it can also be read from WL1023 to WL0 in sequence (i.e., from the high word line to the low word line).

[0047] When reading, first determine the word line to be read (ie, WL0 or WL1023), and then select the 128-bit bit line of the main area 100 and the 1-bit bit line of the redundant area 200 according to the address decoder. Among them, 64 (ie, 2 6 ) times, generally BL0~BL8191 are read in sequence, 128 columns are read each time, and since there are only 8 redundant columns, 1 column is read each time, so on the same word line, when the bit line address of the main area 100 is monotonically increasing from BL0~BL8191, the redundant column address is increased and circulated in rdn0~rdn7, that is, on each word line, the redundant column can be detected multiple times.

[0048] like Figure 2 As shown, the FLASH redundant replacement system of the present invention is configured with two pointers for the redundant area 200, wherein the first pointer rdn_addr represents an index pointer pointing to a redundant column, and the first pointer rdn_addr increases and cycles in rdn0 to rdn7 with the read operation of SA, and the second pointer rdn_no points to a redundant column that is about to be used to replace the defective bit line of the main area 100, and the redundant column address pointed to by the second pointer rdn_no increases monotonically from rdn0 to rdn7 according to the replacement behavior.

[0049] Furthermore, when the SA of the redundant area 200 detects that a redundant column on a certain Word line is bad (i.e., defective), the redundant column is marked as bad, and the second pointer rdn_no is made to skip the redundant column marked as bad when monotonically increasing, thereby avoiding replacing the bad redundant column into the main area 100.

[0050] The FLASH redundancy replacement system of the present invention is also configured with LUT [7:0] [12:0], which is used to indicate the error addresses recorded by the 8 redundant bit lines respectively. LUT [7:0] [12:0] is a register. [7:0] indicates redundant columns rdn0 to rdn7, [12:0] indicates 13-bit data, of which 6-bit data indicates the number of times the defect occurs (i.e., which times the defect occurs), which are 0 to 63 (a total of 2 6= 64 times), 128 SAs need to read the bit line of the main area 100 on the same word line 64 times, and the remaining 7 bits of data represent the address of the main area bit line where the defect occurs, which are 0 to 127 respectively. Since 128 (2 7 ) main area bit lines, 8192 main area bit lines can be read 64 times in a row, so LUT [7:0] [12:0] can record at most 8 error addresses of the main area 100. In other embodiments, the LUT can be configured according to the number of redundant bit lines, the number of main area bit lines, and the number of SAs in the main area.

[0051] In addition, the redundant replacement system is also configured with FLAG[7:0][1:0], which is used to record whether the 8 redundant bit lines are used for replacement and whether they are detected as bad. FLAG[7:0][1:0] is also a register. [7:0] represents redundant columns rdn0 to rdn7, [1:0] represents whether they are used for replacement and whether they are detected as bad, [1:0]=2'b00 represents not used for replacement / not detected as bad, [1:0]=2'b01 represents not used for replacement / detected as bad, [1:0]=2'b10 represents used for replacement / not detected as bad, and [1:0]=2'b11 represents used for replacement / detected as bad. More specifically, FLAG[7:0][1] is used to represent whether it is used for replacement. FLAG[7:0][1]=1 or 0 represents used for replacement or not used for replacement; FLAG[7:0][0]=1 or 0 represents detected as bad or not detected as bad. In other embodiments, FLAG is configured according to the number of redundant bit lines.

[0052] The redundant replacement system of this embodiment is also configured with a self-incrementing structure of the second pointer rdn_no, such as Figure 3As shown, the self-increment structure includes an excluder mask and a priority encoder. The redundant column address currently pointed to by the second pointer rdn_no and FLAG[7:0][1:0] are input into the excluder mask. The excluder mask determines which redundant columns have been used or marked as bad and excludes them based on FLAG[7:0][1:0]. Then, through the priority encoder, the target value of rdn_no+1 or rdn_no+2 is output and the target value is assigned to the original rdn_no. Specifically, when the main area 100 detects a defect and the redundant area 200 does not detect a defect, the output target value is rdn_no+1; when the main area 100 detects a defect and the rdn_no+1 of the redundant area 200 is detected as bad in the previous detection, that is, FLAG[rdn_no+1][0]=1, the output target value is rdn_no+2. When the number of redundant columns used exceeds 8, rdn_no can no longer be added by 1 or 2, and plus_err is output to end the process.

[0053] The present invention also discloses a FLASH redundant replacement method, which adopts the above-mentioned FLASH redundant replacement system. In the process of redundant replacement by the method, on the same word line, each time 128 SAs read the bit line of the main area 100, the position of the bit line of the main area 100 increases monotonically, and increases by 128 positions each time; 1 SA reads the redundant column, and the redundant column address pointed to by the first pointer rdn_addr changes by one position each time, and the redundant column address pointed to by the second pointer rdn_no changes only after the replacement behavior occurs. When a certain bit line of the main area 100 is read to be defective, the redundant column currently pointed to by the second pointer rdn_no is replaced with the defective bit line of the main area 100, and the second pointer rdn_no is made to point to the next redundant column; then the next group of 128 bit lines on the current word line are read, and the corresponding replacement behavior is performed until the current word line is read, and then the next word line is read, until all 1024 word lines are read. The redundant column is replaced with the defective bit line of the main area 100 , which means that when the bit line at the same position of the main area 100 is read later, the replaced bit line, ie, the bit line of the original redundant area 200 , is read.

[0054] It should be noted that after reading a word line, the redundant column pointed to by the second pointer rdn_no remains unchanged, and the direction of the second pointer rdn_no changes only after the replacement behavior occurs. When the second pointer rdn_no increases to 7 (i.e., points to rdn7 pointing to the redundant area 200), and another replacement occurs, if the defective bit line of the main area 100 is still read, the replacement process will be terminated in advance. Because there is no redundant bit line available for replacement at this time, this FLASH is judged as a waste.

[0055] Through the configured LUT[7:0][12:0] and FLAG[7:0][1:0], when FLASH completes the redundant replacement, when accepting host access, when the address main_addr to be accessed by the host matches the information recorded in LUT[12:0], the specific information of LUT[7:0] can be obtained, and then the FLAG[7:0][1:0] corresponding to the LUT[7:0] can be obtained, so as to know whether the address main_addr to be accessed by the host has been replaced and whether it has been detected as bad. Through this configuration, the situation where the initial state of all 0s is considered as a replacement is avoided.

[0056] In specific operations, such as Figure 4 As shown, after the redundant replacement starts, the corresponding logical operation is performed according to the result of each reading of the 129 SAs. During the reading process, if it is found that the number of defective bit lines in the main area 100 is greater than the number of redundant columns, the process is terminated in advance, otherwise the process is terminated until both the word lines and bit lines in the main area 100 reach the maximum value. The result of each reading of the 129 SAs is in the form of X+Y, where X represents the detection result of the main area 100, and Y represents the detection result of the redundant area 200. The detection result is 1 or 0, 1 represents a defect, and 0 represents no defect. Different logical operations are performed according to different reading results X+Y, as follows:

[0057] ①The reading result is 1+0;

[0058] It indicates that the main area 100 currently read out is defective, and the redundant area 200 is not defective. At this time, the redundant column currently pointed to by the second pointer rdn_no is replaced with the defective Bit line of the main area 100; and the error position is recorded using LUT[rdn_no][12:0], and FLAG[rdn_no][1] is set to 1, indicating that rdn_no has been used for replacement; finally, rdn_no is incremented according to the auto-increment structure;

[0059] ②The reading result is 0+1, and specifically includes the following situations:

[0060] FLAG[rdn_addr][1] = 1 and rdn_addr < rdn_no: This indicates that the previous replacement rdn_addr was detected as bad. At this time, set FLAG[rdn_addr][1] to 0, set FLAG[rdn_addr][0] to 1, indicating that rdn_addr was detected as bad; and assign LUT[rdn_addr] the value of LUT[rdn_no], and set FLAG[rdn_no][1] to 1; finally, increment rdn_no according to the increment structure.

[0061] FLAG[rdn_addr][1] = 0 and rdn_addr < rdn_no: This indicates that the redundant defect bit after processing is detected again, and no further operation is required. After processing, there is no need for further operation;

[0062] FLAG[rdn_addr][1] = 0 and rdn_addr = rdn_no: At this time, set FLAG[rdn_no][0] to 1; finally, increment rdn_no according to the increment structure.

[0063] FLAG[rdn_addr][1] = 0 and rdn_addr > rdn_no: Set FLAG[rdn_addr][0] to 1, indicating that rdn_addr was detected as bad;

[0064] ③ The read result is 1 + 1, and specifically includes the following situations:

[0065] FLAG[rdn_addr][1] = 1 and rdn_addr < rdn_no and not the situation in:

[0066] At this time, replace the Bit line of the redundant area 200 currently pointed to by the second pointer rdn_no with the defective Bit line of the main area 100;

[0067] And use LUT[rdn_no][12:0] to record the error location; set FLAG[rdn_no][1:0] = 2'b10, indicating that the current rdn_no is used for replacement and has not been detected as bad;

[0068] And assign the error address in LUT[rdn_addr] to LUT[rdn_no + 1], and set FLAG[rdn_no + 1][1:0] = 2'b10;

[0069] Set FLAG[rdn_addr][1:0] = 2'b01;

[0070] Finally, increment rdn_no according to the auto-increment structure;

[0071] FLAG[rdn_addr][1] = 0 and rdn_addr < rdn_no and not the cases in;

[0072] At this time, replace the Bit line of the redundant area 200 currently pointed to by the second pointer rdn_no with the defective Bit line of the main area 100;

[0073] And use LUT[rdn_no][12:0] to record the error location, and make FLAG[rdn_no][1:0] = 2'b10;

[0074] Finally, increment rdn_no according to the auto-increment structure;

[0075] FLAG[rdn_addr][1] = 0 and rdn_addr = rdn_no and not the cases in;

[0076] At this time, replace the Bit line of the redundant area 200 currently pointed to by the second pointer rdn_no with the defective Bit line of the main area 100;

[0077] And use LUT[rdn_no + 1][12:0] to record the error location, and make FLAG[rdn_no + 1][1:0] = 2'b10; make FLAG[rdn_addr][1:0] = 2'b01;

[0078] Finally, increment rdn_no according to the auto-increment structure;

[0079] FLAG[rdn_addr][1] = 0 and rdn_addr > rdn_no and not the cases in;

[0080] At this time, replace the Bit line of the redundant area 200 currently pointed to by the second pointer rdn_no with the defective Bit line of the main area 100;

[0081] And use LUT[rdn_no][12:0] to record the error location, and make FLAG[rdn_no][1:0] = 2'b10; make FLAG[rdn_addr][1:0] = 2'b01, indicating that the current rdn_addr is not used for replacement and is detected as bad;

[0082] Finally, make rdn_no increment according to the auto-increment structure;

[0083] The current address of the main area 100 has been replaced and the error position is equal to the record position;

[0084] At this time, the Bit line of the redundant area 200 currently pointed to by the second pointer rdn_no is replaced with the defective Bit line of the main area 100;

[0085] LUT[mapped_idx] is assigned to LUT[rdn_no], where, since the current address of the main area 100 has been replaced, mapped_idx refers to the bit line of the redundant area 200 corresponding to the time when the current address of the main area 100 was replaced;

[0086] FLAG[mapped_idx]=2'b01;

[0087] Finally, make rdn_no increment according to the auto-increment structure;

[0088] ④Others: When any situation other than ① to ③ above occurs, the process is stopped and the FLASH is judged to be a waste.

[0089] When the entire main area 100 is detected and replaced, the final result recorded by LUT[7:0][12:0] is written into FLASH, and the entire redundant replacement process is completed. By writing the final result recorded by LUT[7:0][12:0] into FLASH, LUT[7:0][12:0] is loaded into the digital logic for use each time the power is turned on, thereby ensuring the normal operation of FLASH.

[0090] Although the content of the present invention has been described in detail through the above preferred embodiments, it should be appreciated that the above description should not be considered as a limitation of the present invention. After reading the above content, it will be apparent to those skilled in the art that various modifications and substitutions of the present invention will occur. Therefore, the protection scope of the present invention should be limited by the appended claims.

Claims

1. A FLASH redundancy replacement system for replacing defective bit lines in a main area with bit lines in a redundant area, characterized in that: include: Multiple SAs, one of which is used to sequentially read M+1 bit lines in the redundant area, and the SA in the redundant area reads one bit line in the redundant area each time; The other multiple SAs are used to read the bit lines of the main area in sequence, and the SA of the main area reads multiple bit lines of the main area each time; A first pointer rdn_addr, serving as an index pointer for the bit lines in the redundant area, the first pointer rdn_addr circulates among all the bit lines rdn0 to rdnM in the redundant area as SA is read; The second pointer rdn_no points to a redundant area bit line used to replace a defective bit line in the main area. The redundant area bit lines pointed to by the second pointer rdn_no increase monotonically from rdn0 to rdnM.

2. The FLASH redundancy replacement system according to claim 1, characterized in that: Also includes: FLAG[M:0][1:0], used to record whether a plurality of bit lines in the redundant area are used for replacement and whether they are detected as bad, wherein [M:0] indicates bit lines rdn0 to rdnM in the redundant area, and [1:0] indicates whether they are used for replacement and whether they are detected as bad; LUT[M:0][N:0] indicates the error addresses recorded by the M+1 bit lines in the redundant area, where N=N1+N2-1, [N:0] indicates N+1 bits of data, where N1 bits of data indicate the number of times the defect occurs. The number of times multiple SAs complete the reading of the main area bit lines of the same word line is 2 N1 , N2-bit data indicates the address of the main area bit line where the defect occurs, 2 N2 Number of SAs in the primary area.

3. The FLASH redundancy replacement system as claimed in claim 2, characterized in that: Also includes: The self-increment structure of the second pointer rdn_no includes an excluder and a priority encoder. The specific bit line address of the redundant area currently pointed to by the second pointer rdn_no and FLAG[M:0][1:0] are input into the excluder. The excluder determines which redundant bit lines have been used or marked as bad and excludes them based on FLAG[M:0][1:0]. Then, the target value of rdn_no+1 or rdn_no+2 is output through the priority encoder, and the target value is assigned to the original second pointer rdn_no.

4. A FLASH redundancy replacement method, using the FLASH redundancy replacement system according to any one of claims 1 to 3, characterized in that: When performing redundancy replacement on FLASH, first determine the word line to be read. On the same word line, when a bit line in the main area is found to be defective, replace the bit line in the redundant area currently pointed to by the second pointer rdn_no with the defective bit line in the main area, and make the second pointer rdn_no point to the next bit line in the redundant area. Then read the next group of bit lines on the current word line and perform corresponding replacement behavior until the current word line is read, and then read the next word line until all word lines in the main area are read.

5. The FLASH redundancy replacement method according to claim 4, characterized in that: When the second pointer rdn_no points to the last bit line of the redundant area and another replacement occurs, if a defective bit line of the main area is still read, the replacement process is terminated and the FLASH is judged as a waste.

6. The FLASH redundancy replacement method according to claim 5, characterized in that: When the SA of the redundant area detects that a bit line of the redundant area is defective, the bit line of the redundant area is marked as bad; and the second pointer rdn_no is made to skip the bit line marked as bad when monotonically increasing.

7. The FLASH redundancy replacement method according to claim 6, characterized in that: After FLASH completes the redundant replacement, when accepting host access, when the address main_addr that the host wants to access matches the information recorded in LUT[N:0], the specific information of LUT[M:0] can be obtained, and then the FLAG[M:0][1:0] corresponding to the LUT[M:0] can be obtained, so as to know whether the address main_addr that the host wants to access has been replaced and whether it has been detected as bad.

8. The FLASH redundancy replacement method according to claim 7, characterized in that: After the redundant replacement starts, the corresponding logical operation is performed according to the results of each reading of multiple SAs. During the reading process, if it is found that the number of defective bit lines in the main area is greater than the number of bit lines in the redundant area, the process is terminated in advance. Otherwise, the process ends when both the word lines and bit lines in the main area reach the maximum value.

9. The FLASH redundancy replacement method according to claim 8, characterized in that: The result of each read of multiple SAs is in the form of X+Y, where X represents the detection result of the main area, and Y represents the detection result of the redundant area. The detection result is 1 or 0, 1 represents a defect, and 0 represents no defect. Different logical operations are performed according to different reading results X+Y, as follows: ① The reading result is 1+0: the bit line of the redundant area currently pointed to by the second pointer rdn_no is replaced with the defective bit line of the main area; and LUT[rdn_no][N:0] is used to record the error position, and FLAG[rdn_no][1] is set to 1, indicating that rdn_no has been used for replacement; rdn_no is incremented according to the self-increment structure; ②The reading result is 0+1, and specifically includes the following situations: If FLAG[rdn_addr][1] == 1 and rdn_addr < rdn_no, set FLAG[rdn_addr][1] to 0, set FLAG[rdn_addr][0] to 1; assign LUT[rdn_addr] with LUT[rdn_no], and set FLAG[rdn_no][1] to 1; increment rdn_no according to the increment structure; FLAG[rdn_addr][1] = 0 and rdn_addr < rdn_no: No need to operate again; FLAG[rdn_addr][1]=0 and rdn_addr=rdn_no: set FLAG[rdn_no][0] to 1; make rdn_no increment according to the auto-increment structure; FLAG[rdn_addr][1]=0 and rdn_addr>rdn_no: set FLAG[rdn_addr][0] to 1; ③The reading result is 1+1, and specifically includes the following situations: FLAG[rdn_addr][1] = 1 and rdn_addr < rdn_no and not in the following case: Replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of the main area; And use LUT[rdn_no][N:0] to record the error position; set FLAG[rdn_no][1:0]=2'b10, indicating that rdn_no is used for replacement and has not been detected as bad; assign the error address in LUT[rdn_addr] to LUT[rdn_no+1], set FLAG[rdn_no+1][1:0]=2'b10; set FLAG[rdn_addr][1:0]=2'b01, indicating that rdn_addr is not used for replacement and has not been detected as bad; finally, make rdn_no self-increment according to the self-increment structure; FLAG[rdn_addr][1] = 0 and rdn_addr < rdn_no and not the case in: replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of the main area; and use LUT[rdn_no][N:0] to record the error location, make FLAG[rdn_no][1:0] = 2'b10; finally, increment rdn_no according to the self-increment structure; FLAG[rdn_addr][1]=0 and rdn_addr=rdn_no and not In the case of: the bit line of the redundant area currently pointed to by the second pointer rdn_no is replaced by the defective bit line of the main area; Use LUT[rdn_no+1][N:0] to record the error position, set FLAG[rdn_no+1][1:0]=2'b10; set FLAG[rdn_addr][1:0]=2'b01; finally, make rdn_no increment according to the auto-increment structure; FLAG[rdn_addr][1] = 0 and rdn_addr > rdn_no and not the situation in: replace the bit line of the redundant area currently pointed to by the second pointer rdn_no with the defective bit line of the main area; and use LUT[rdn_no][N:0] to record the error location, make FLAG[rdn_no][1:0] = 2'b10; make FLAG[rdn_addr][1:0] = 2'b01; finally, make rdn_no increment according to the increment structure; The current address of the main area 100 has been replaced and the error position is equal to the recorded position; the bit line of the redundant area currently pointed to by the second pointer rdn_no is replaced with the defective bit line of the main area; LUT[mapped_idx] is assigned to LUT[rdn_no], where, since the current address of the main area 100 has been replaced, mapped_idx refers to the Bit line of the redundant area 200 corresponding to the replacement before the current address of the main area 100; FLAG[mapped_idx] = 2'b01; finally, rdn_no is incremented according to the auto-increment structure; ④Others: When any situation other than ① to ③ above occurs, the process is stopped and the FLASH is judged to be a waste.