Abstract:
Methods for providing redundancy in a memory include mapping a portion of first data associated with an address of the memory determined to indicate a defective memory cell to an address of a redundant area of the memory array, and writing second data to the memory array, wherein a portion of the second data is written to a column of the memory array associated with the address of the memory determined to indicate a defective memory cell for the first data. Apparatus include memory control circuitry configured to select a portion of data for mapping to a different address in response to an address indicating a defective memory cell, and further configured to select a different portion of data for a particular row than for a different row, wherein the particular row and the different row are associated with the same columns of the memory array.

Description:
RELATED APPLICATIONS 
       [0001]    This application is a Continuation of U.S. patent application Ser. No. 13/208,502 filed Aug. 12, 2011 (allowed) which is commonly assigned and incorporated herein by reference in its entirety. 
     
    
     TECHNICAL FIELD 
       [0002]    The present embodiments relate generally to memory and a particular embodiment relates to column redundancy in a memory device. 
       BACKGROUND 
       [0003]    Flash memory devices have developed into a popular source of non-volatile memory for a wide range of electronic applications. Flash memory devices typically use a one-transistor memory cell that allows for high memory densities, high reliability, and low power consumption. Common uses for flash memory include personal computers, flash drives, digital cameras, and cellular telephones. Program code and system data such as a basic input/output system (BIOS) are typically stored in flash memory devices for use in personal computer systems. 
         [0004]    A typical non-volatile memory device is a type of memory in which the array of memory cells is typically organized into memory blocks that can be erased and reprogrammed on block-by-block basis instead of one byte at a time. Changes in a threshold voltage of each of the memory cells, through erasing or programming of a charge storage structure (e.g., floating gate or charge trap) or other physical phenomena (e.g., phase change or polarization), determine the data value of each cell. The data in a cell of this type are determined by the presence or absence of the charge in the charge storage structure. 
         [0005]    Non-volatile memory devices typically have a reserved area in the memory array for redundant columns (e.g., bit lines) of memory cells. The redundant columns can be used when a particular address is determined to indicate a defective memory cell (with such an address being sometimes referred to herein as a “defective address”). For example, a bit line-to-bit line shorting condition or a single cell failure can use a redundant column to repair the defective condition. 
         [0006]    Mapping a redundant column to a defective column typically comprises comparing each received address to a list of defective addresses while a data load operation is being performed. If an address to be programmed is found to be defective, the system deselects the defective address and selects the corresponding redundant column. Since the comparing is performed in real time as the data to be programmed is loaded into the page buffer, the architecture needs to be fast enough to follow the I/O speed in order to reduce any data bottlenecks. This can result in difficult design constraints for timing purposes. 
         [0007]    The redundant column mapping also maps an entire column when only a single memory in a column has been determined to be defective. For example, one defective memory address can result in a byte or more of the redundant column area of the memory array being assigned to repair the defective address. This can result in an ineffective use of redundant columns of memory cells. 
         [0008]    For the reasons stated above and for other reasons that will become apparent to those skilled in the art upon reading and understanding the present specification, there is a need in the art for a more efficient scheme for redundancy. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0009]      FIG. 1  shows a schematic diagram of one embodiment of a portion of a NAND architecture memory array. 
           [0010]      FIGS. 2A and 2B  show block diagrams of one embodiment of a column redundancy scheme. 
           [0011]      FIG. 3  shows a functional block diagram of one embodiment of a state machine in accordance with the embodiment of  FIGS. 2A and 2B . 
           [0012]      FIG. 4  shows a flowchart of one embodiment of a method for providing column redundancy in accordance with the embodiment of  FIGS. 2A and 2B . 
           [0013]      FIG. 5  shows a block diagram of one embodiment of a memory system that can incorporate a stacked memory array architecture using the described methods for sense operations. 
       
    
    
     DETAILED DESCRIPTION 
       [0014]    In the following detailed description, reference is made to the accompanying drawings that form a part hereof and in which is shown, by way of illustration, specific embodiments. In the drawings, like numerals describe substantially similar components throughout the several views. Other embodiments may be utilized and structural, logical, and electrical changes may be made without departing from the scope of the present disclosure. The following detailed description is, therefore, not to be taken in a limiting sense. 
         [0015]      FIG. 1  illustrates a schematic diagram of one embodiment of a portion of a NAND architecture memory array  101  comprising series strings of non-volatile memory cells. The schematic diagram of  FIG. 1  is for purposes of illustration only as the memory array architecture is not limited to the illustrated NAND architecture. Alternate embodiments can use NOR or other architectures as well. 
         [0016]    The memory array  101  comprises an array of non-volatile memory cells (e.g., floating gate) arranged in columns such as series strings  104 ,  105 . Each of the cells is coupled drain to source in each series string  104 ,  105 . An access line (e.g. word line) WL 0 -WL 31  that spans across multiple series strings  104 ,  105  is coupled to the control gates of each memory cell in a row in order to bias the control gates of the memory cells in the row. Data lines, such as even/odd bit lines BL_E, BL_O, are coupled to the series strings and eventually each bit line is coupled to a page buffer with sense circuitry that detects the state of each cell by sensing current or voltage on a selected bit line. 
         [0017]    Each series string  104 ,  105  of memory cells is coupled to a source line  106  by a source select gate  116 ,  117  (e.g., transistor) and to an individual bit line BL_E, BL_O by a drain select gate  112 ,  113  (e.g., transistor). The source select gates  116 ,  117  are controlled by a source select gate control line SG(S)  118  coupled to their control gates. The drain select gates  112 ,  113  are controlled by a drain select gate control line SG(D)  114 . 
         [0018]    Each memory cell can be programmed as a single level cell (SLC) or a multiple level cell (MLC). Each cell&#39;s threshold voltage (V t ) is indicative of the data that is stored in the cell. For example, in an SLC, a V t  of 2.5V might indicate a programmed cell while a V t  of −0.5V might indicate an erased cell. An MLC uses multiple V t  ranges that each indicates a different state. Multiple level cells can take advantage of the analog nature of a traditional flash cell by assigning a bit pattern to a specific V t  range. This technology permits the storage of data values representing two or more bits per cell, depending on the quantity of V t  ranges assigned to the cell. 
         [0019]      FIGS. 2A and 2B  illustrate block diagrams of one embodiment of a column redundancy scheme that can be used with a memory array such as the array illustrated in  FIG. 1 .  FIG. 2A  illustrates the column redundancy scheme as used in a programming operation.  FIG. 2B  illustrates the column redundancy scheme as used in a sense (e.g., read) operation. 
         [0020]      FIG. 2A  illustrates the memory device  200  that includes a memory array  201  such as the portion of the array illustrated in  FIG. 1 . The array  201  includes redundant column area  202  set aside for column redundancy. As described previously, the redundant column area  202  of the array provides redundant (e.g., back-up) memory cells for replacing memory cells determined to be defective in the main memory array  201 . 
         [0021]    A page buffer  203  is coupled to the memory array  201  and redundant column area  202 . The page buffer  203  temporarily stores data that is to be written to the memory array  201  during a programming operation. The data  210  are input from input/output (I/O) connections of the memory device. As will be seen with reference to  FIG. 2B , the page buffer  203  also stores data that has been read from the memory array  202 . 
         [0022]    An address generator (Adr. Gen.)  205  is coupled to the page buffer  203 . The address generator  205  generates the addresses for programming data as it is being written to the page buffer  203 . Each address determines where in the page buffer associated data is to be programmed. The page buffer addresses are each associated with a respective address in the memory array to which the data are to be programmed. 
         [0023]    A defective column memory block  207  is coupled to a state machine  209  that is coupled to the page buffer  203 . The defective column memory block  207  stores the column addresses of the memory array  201  that have been determined to indicate a defective memory cell or cells. In one embodiment, the defective column address determination can be accomplished during a self-test of the memory array whenever the memory device  200  is powered-up. An alternate embodiment might determine which cells are defective during manufacture of the memory device and store the addresses of those defective cells in the defective column memory block  207 . 
         [0024]    The state machine  209  can be hardware, software, or a combination of hardware and software. The state machine  209  can be executed by a controller or the controller along with executable code might be considered a state machine. 
         [0025]    In operation, a data load operation occurs prior to the programming of the memory array  201 . During the data load operation, the data are stored in the page buffer  203  without any skipping for defective column addresses as is done in the prior art. In other words, the defective address matching is not performed during the data loading operation of the page buffer  203 . 
         [0026]    The loaded data are confirmed to be properly stored into the page buffer  203 . The state machine  209  then maps (e.g., copies) the data from the page buffer addresses associated with defective addresses in the memory array  201  to page buffer addresses associated with redundant memory cells. The state machine can also exclude the defective addresses from the pass/fail checking of the memory array  201 . The data are then transferred from the page buffer  203  to the appropriate addresses in the memory array  201  for programming. 
         [0027]    Since the state machine  209  manages each bit of the page buffer  203 , the illustrated column redundancy scheme can operate on a per bit or per byte basis. The prior art replaced the entire column of memory cells. 
         [0028]      FIG. 2B  illustrates substantially the same architecture as  FIG. 2A . However, the data in  FIG. 2B  is being read from the memory array  201 . 
         [0029]    In the read operation embodiment of  FIG. 2B , the read operation transfers the data read from the memory array  201  to the page buffer  203  for temporary storage. The data are read from locations in the memory array  201  and transferred to their associated locations in the page buffer  203  without address skipping for defective addresses, as is done in the prior art. After a read verify of data in the page buffer  203 , the state machine  209  maps (e.g., copies, moves) the data from the page buffer address associated with the redundant column address to the page buffer address associated with the defective column address. The data are then output to the I/O connections with their appropriate addresses. 
         [0030]      FIG. 3  illustrates a functional block diagram of one embodiment of a state machine in accordance with the embodiment of  FIGS. 2A and 2B . The block diagram of  FIG. 3  is for purposes of illustration only as the state machine can be implemented in other ways, both software and hardware. 
         [0031]    The state machine can include a memory block  301  (e.g., SRAM) configured to store addresses of the memory determined to indicate defective memory cells. For example, the address might indicate that bit  3  of a particular byte is defective. A BIT/BYTE block  303  is coupled to the memory block  301 . The defective address (ADR) that is read from the memory block  301  is passed  302  to the BIT/BYTE block  303 . The BIT/BYTE block  303  provides a logic function (e.g., decoder) that selects the defective bit or byte (e.g., 011 of 00001000), depending on how many bits are defective. 
         [0032]    The PB_DRV block  305 , coupled between the BIT portion of the BIT/BYTE block  303  and the page buffer  309 , provides a driver function to control the page buffer  309 . In the present example of bit  3  being defective, the PB_DRV block  305  enables just the bit&lt;3&gt; of page buffer address 00001000. 
         [0033]    The COL_DEC block  307 , coupled between the BYTE portion of the BIT/BYTE block  303  and the page buffer  309 , provides a column decoder function for accessing the page buffer  309 . This block  307  generates signals to select the proper byte according to the address from the memory block  301 . 
         [0034]      FIG. 4  illustrates a flowchart of one embodiment of a method for providing column redundancy in a memory device, such as the device illustrated in  FIG. 5 . The method determines if a read or program operation is being performed  401 . 
         [0035]    If a read operation is being performed, data is read from the memory array  411  and all the data are loaded into the page buffer  413 . Unlike the prior art, no address matching is performed at this point and no defective addresses are skipped. Also, when the data are read from the memory array  411 , the mapped redundant addresses are read. A read verify is performed to verify that the data have been loaded into the page buffer  415 . 
         [0036]    The data that were read from the redundant addresses are then mapped (e.g., copied, moved) to the page buffer addresses associated with the originally defective addresses  417 . The data are then output over the I/O connections  420 . 
         [0037]    If a program operation is being performed, data input from the I/O connections are all loaded into the page buffer  403 . Unlike the prior art, no address matching is performed at this point and no defective addresses are skipped. The data is then verified to determine that it has been properly loaded into the page buffer  405 . 
         [0038]    Data that are to be programmed to defective addresses are mapped (e.g., copied, moved) to redundant addresses  407 . As shown in  FIGS. 2A and 2B , the defective addresses can be determined by reading the defective column memory that stores the defective addresses. The data are then programmed to the memory array  409 . The data that were originally assigned to defective addresses are programmed to the mapped redundant memory addresses. The program operation can include a program verify as well. 
         [0039]      FIG. 5  illustrates a functional block diagram of a memory device  500  that can comprise the column redundancy scheme in accordance with  FIGS. 2A and 2B . The memory device  500  is coupled to a processor  510 . The processor  510  may be a microprocessor or some other type of controller. The memory device  500  and the processor  510  form part of a memory system  520 . An apparatus can refer to either a device (e.g., a memory device) alone or as part of a system (e.g., a memory system). 
         [0040]    The memory device  500  includes an array  530  of memory cells (e.g., non-volatile memory cells) in accordance with the embodiments of  FIGS. 2A and 2B . The memory array  530  is arranged in banks of word line rows and bit line columns. In one embodiment, the columns of the memory array  530  comprise series strings of memory cells. 
         [0041]    Address buffer circuitry  540  is provided to latch address signals provided through I/O circuitry  560 . Address signals are received and decoded by a row decoder  544  and a column decoder  546  to access the memory array  530 . 
         [0042]    The memory device  500  reads data in the memory array  530  by sensing voltage or current changes in the memory array columns using sense amplifier circuitry  550 . The page buffers  550 , in one embodiment, are coupled to read and latch a row of data from the memory array  530 . The page buffers  550 , as previously described, include the sense circuitry as well as other circuits for performing a program verify operation. Data are input and output through the I/O circuitry  560  for bidirectional data communication as well as the address communication over a plurality of data connections  562  with the controller  510 . Write circuitry  555  is provided to write data to the memory array. 
         [0043]    Memory control circuitry  570  decodes signals provided on control connections  572  from the processor  510 . These signals are used to control the operations on the memory array  530 , including data read, data write (program), and erase operations. The memory control circuitry  570  may be a state machine, a sequencer, or some other type of controller to generate the memory control signals. In one embodiment, the memory control circuitry  570  is configured to control execution of the column redundancy embodiments of the present disclosure. 
         [0044]    The memory device illustrated in  FIG. 5  has been simplified to facilitate a basic understanding of the features of the memory. A more detailed understanding of internal circuitry and functions of flash memories are known to those skilled in the art. 
       CONCLUSION 
       [0045]    In summary, one or more embodiments of redundancy provide redundant memory cells for memory cells determined to be defective on a bit-by-bit or byte-by-byte basis. By performing the mapping (e.g., copying, moving) after all the data has been loaded into the page buffer, from either the I/O connections during a program operation or the memory array during a read operation, the need for real time address comparison can be eliminated along with its associated problems. 
         [0046]    Although specific embodiments have been illustrated and described herein, it will be appreciated by those of ordinary skill in the art that any arrangement that is calculated to achieve the same purpose may be substituted for the specific embodiments shown. Many adaptations of the invention will be apparent to those of ordinary skill in the art. Accordingly, this application is intended to cover any adaptations or variations of the invention.