Method for performing read and write operations in cells of NAND memory

Through the memory controller, data mapping and back copying is used to use the support unit block and L2P tables to map and copy data, the problem of high resource consumption of the host controller is solved and the programming efficiency and performance of NAND memory is improved.

CN118939176APending Publication Date: 2024-11-12SAMSUNG ELECTRONICS CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202311055166.9
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2023-05-12
Filing Date
2023-08-21
Publication Date
2024-11-12

AI Technical Summary

Technical Problem

When existing host controllers perform advanced unit block programming of NAND memory, they require a large amount of data buffer resources, resulting in high resource consumption and difficulty in programming effectively.

Method used

Data mapping and copying back operations are performed through the memory controller using support unit blocks and logic to physical tables (L2P tables), reducing dependence on host controller resources, and writing and reading operations are performed directly in NAND memory.

Benefits of technology

Reduces resource consumption of host controllers when writing and reading advanced unit blocks, improves performance and operation speed of NAND memory, reduces the need for buffers, and supports programming of more advanced unit blocks.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118939176A_ABST
    Figure CN118939176A_ABST
Patent Text Reader

Abstract

Example embodiments of the present disclosure disclose methods for performing read and write operations in cells of a NAND memory. A memory controller of the NAND memory receives a write request from a host controller for writing data present in a set of supporting cell blocks of the NAND memory into an "n" level cell block of the NAND memory. The write request includes information about a mapping between the set of support cell blocks and the "n" level cell blocks. The mapping between the set of support unit blocks and the "n" level unit blocks is used to update the L2P table. Further, the memory controller performs a copy back operation on the set of support cell blocks based on the L2P table using the NAND latch to write data to the "n" level cell block. Upon receiving a read request, the host controller retrieves data from at least one support unit block associated with the "n" level unit block based on the mapping upon determining that the "n" level unit block is listed in the active block list.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present disclosure relates generally to NAND memory, and more particularly, to a method and system for performing read and write operations in a cell of a NAND memory. Background Art

[0002] Solid-state drives (SSDs) based on NAND (NAND) memory are increasingly used in many applications, especially for portable and consumer devices. NAND memory stores data in "n" level cell blocks (such as single-level cell (SLC) blocks, multi-level cell (MLC) blocks, triple-level cell (TLC) blocks, quad-level cell (QLC) blocks, penta-level cell (PLC) blocks, etc.), where "n" represents the number of bits of data that can be stored in one NAND cell block. Thus, SLC blocks store 1 bit per cell block, MLC blocks store 2 bits per cell block, TLC blocks store 3 bits per cell block, QLC blocks store 4 bits per cell block, PLC blocks store 5 bits per cell block, and so on. Thus, the memory controller in NAND memory is a key component of a storage device that manages data transfer between a host controller and NAND memory and is used to implement reliable flash-based storage.

[0003] Typically, the host controller includes a data buffer for temporarily storing data read from the NAND memory and data written to the NAND memory. More specifically, these data buffers are required in the host controller due to the different speeds and data sizes used by the host controller and the NAND memory. In addition, in some instances, the data from the host controller may need to be reorganized before being written to the NAND memory. Once again, due to the protocols, processes, priorities, etc. of the NAND memory, the data from the host controller may be reorganized before being written to the NAND memory. For example, writing data to the QLC cell of the NAND memory involves a two-pass approach (or a two-step approach, two-pass approach) because it requires more levels of voltage to be stored in the QLC cell block. In other words, in the two-pass approach, during the programming of the "n" level cell block, the host controller needs to store / keep the data in the data buffer for a period of time. In this way, performing multi-plane QLC programming operations by the host controller requires a large amount of additional resources (i.e., data buffers) to store the firmware structure. Typically, the number of data buffers required for programming the "n" level cell block in the host controller is high. However, the host controller has limited available memory (TCM, SRAM, system DRAM, etc.), which makes it difficult to program the "n" level cell blocks using the existing host controller. Summary of the invention

[0004] In an example embodiment, a method for writing data into a cell of a NAND (NAND) memory is disclosed. The method includes: receiving a write request by a memory controller of the NAND memory from a host controller, the write request being used to write data present in a set of support cell blocks of the NAND memory into an "n" level cell block of the NAND memory. The write request includes information about a mapping between the set of support cell blocks and the "n" level cell blocks. The method includes: updating a logical to physical (L2P) table by the memory controller based on the mapping between the set of support cell blocks and the "n" level cell blocks. In addition, the method includes: performing a copy-back operation on the set of support cell blocks based on the L2P table by the memory controller using one or more NAND latches to write data to the "n" level cell block.

[0005] In another example embodiment, a method for reading data from a cell in a NAND memory. The method includes: receiving, by a memory controller of the NAND memory, a read request from a host controller, the read request being used to read data from an "n" level cell block of the NAND memory. The method includes: checking, by the memory controller, whether the "n" level cell block of the NAND memory is listed in an active block list. The active block list includes information about non-idle "n" level cell blocks and non-idle support cell blocks. The method includes: obtaining, by the memory controller, a mapping between a set of support cell blocks and the "n" level cell block based on determining that the "n" level cell block of the NAND memory is listed in the active block list. In addition, the method includes: obtaining, by the memory controller, data from at least one support cell block in the set of support cell blocks associated with the "n" level cell block based on the mapping. Data from the at least one support cell block is provided to the host controller.

[0006] In yet another example embodiment, a memory controller for writing data into a cell of a NAND memory is disclosed. The memory controller includes a memory and a processor. The memory is configured to store instructions, and the processor is configured to execute the instructions stored in the memory and cause the memory controller to receive a write request from a host controller, the write request being used to write data present in a set of support cell blocks of the NAND memory into an "n" level cell block of the NAND memory. The write request includes information about a mapping between the set of support cell blocks and the "n" level cell blocks. The memory controller is caused to update a logical to physical (L2P) table based on the mapping between the set of support cell blocks and the "n" level cell blocks. The memory controller is caused to perform a copy-back operation on the set of support cell blocks based on the L2P table using one or more NAND latches to write data into the "n" level cell block.

[0007] In yet another example embodiment, a memory controller for reading data into a cell of a NAND memory is disclosed. The memory controller includes a memory and a processor. The memory is configured to store instructions, and the processor is configured to execute the instructions stored in the memory and cause the memory controller to receive a read request from a host controller, the read request being used to read data from an "n" level cell block of a NAND memory. The memory controller is caused to check whether the "n" level cell block of the NAND memory is listed in an active block list. The active block list includes information about non-idle "n" level cell blocks and non-idle support cell blocks. Based on determining that the "n" level cell block of the NAND memory is listed in the active block list, the memory controller is caused to obtain a mapping between the set of support cell blocks and the "n" level cell block. The memory controller is caused to obtain data from at least one support cell block in a set of support cell blocks associated with the "n" level cell block based on the mapping. Data from the at least one support cell block is provided to the host controller.

[0008] The foregoing summary is illustrative only and is not intended to be limiting in any way. In addition to the illustrative aspects, example embodiments, and features described above, further aspects, example embodiments, and features will become apparent by reference to the drawings and the following detailed description. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] The accompanying drawings, which are included in and constitute a part of the present disclosure, illustrate example embodiments and, together with the description, serve to explain the principles disclosed. Throughout the drawings, the same reference numerals are used to represent the same features and components. Some example embodiments of the apparatus and / or method according to example embodiments of the present subject matter will now be described by way of example only and with reference to the accompanying drawings, in which:

[0010] Figure 1 is a block diagram representation 100 of a NAND memory in communication with a host controller 130 to program an "n" level block of cells according to an example embodiment of the present disclosure;

[0011] Figure 2 A memory controller for writing / reading data into / from a cell of a NAND memory according to an example embodiment of the present disclosure is shown;

[0012] Figure 3A is an example representation of writing data into a quad-level cell (QLC) block of a NAND memory according to an example embodiment of the present disclosure;

[0013] Figure 3Bis an example representation of writing data into a quad-level cell (QLC) block of a NAND memory according to another example embodiment of the present disclosure;

[0014] Figure 4 A flow chart showing a sequence for writing data into a cell of a NAND memory according to an example embodiment of the present disclosure;

[0015] Figure 5 is a flow chart illustrating a method for writing data into a cell of a NAND memory according to an example embodiment of the present disclosure;

[0016] Figure 6 is a flow chart illustrating a method for reading data from a cell of a NAND memory according to an example embodiment of the present disclosure; and

[0017] Figure 7 A block diagram of a general purpose computer for performing read-write operations in a NAND memory is shown according to an example embodiment of the present disclosure.

[0018] Those skilled in the art will appreciate that any block diagrams herein represent conceptual diagrams of illustrative systems that embody the principles of the present subject matter. Similarly, it will be appreciated that any flow charts, flow diagrams, state transition diagrams, pseudo-codes, etc. represent various processes that can be substantially represented in a computer-readable medium and executed by a computer or processor, whether or not such a computer or processor is explicitly shown. DETAILED DESCRIPTION

[0019] Although the disclosure is susceptible to various modifications and alternative forms, specific example embodiments of the disclosure have been shown by way of example in the drawings and will be described in detail below. However, it should be understood that it is not intended to limit the disclosure to the specific forms disclosed, but on the contrary, the disclosure will cover all modifications, equivalents and alternatives that fall within the spirit and scope of the disclosure.

[0020] The terms "comprises," "includes," or any other variation thereof are intended to cover a non-exclusive inclusion, such that a setup, device, or method that includes a series of components or steps includes not only those components or steps, but may also include other components or steps not expressly listed or inherent to such setup, device, or method. In other words, without more constraints, one or more elements in a device, system, or apparatus beginning with "comprises ..." do not exclude the presence of other elements or additional elements in the device, system, or apparatus.

[0021] In the detailed description of the example embodiments disclosed below, reference is made to the accompanying drawings that form a part of the disclosure, and in the accompanying drawings, specific example embodiments in which the disclosure may be practiced are shown by way of illustration. These example embodiments are described in sufficient detail to enable those skilled in the art to practice the disclosure, and it will be understood that other example embodiments may be utilized and changes may be made without departing from the scope of the disclosure. Therefore, the following description should not be considered in a limiting sense.

[0022] Figure 1 1 is a block diagram representation 100 of a memory device 102 communicating with a host controller 130 to program an "n" level cell block according to an example embodiment of the present disclosure. The memory device 102 may include a memory device 104 and a memory controller 120. The memory device 102 may support multiple channels ch 1 Toch m , and the memory device 104 can be connected through multiple channels ch 1 Toch m Connected to the memory controller 120. For example, the storage device 102 may be implemented as a storage device such as a solid-state device (SSD).

[0023] The memory device 104 may include a plurality of NAND memories N 11 To N mn . Multiple NAND memories N 11 To N mn The NAND memories N may be arranged in memory banks, and each memory bank is connected to the memory controller 120 via a channel. 11 To N mn Each NAND memory in the system can be connected to multiple channels ch through its corresponding path. 1 Toch m For example, NAND memory N 11 To N 1n Through the path w 11 tow 1n Connect to the first channel ch 1 , and NAND memory N 21 To N 2n Through the path w 21 tow 2n Connect to the second channel ch 2 In one example embodiment, the NAND memory N 11 To N mn Each (or optionally, at least one) of the NAND memory cells may be implemented as any memory cell that can be operated according to a separate command from the memory controller 120. For example, the NAND memory N 11 To N mnEach (or optionally, at least one) of the may be implemented as a chip or a die, but the inventive concept is not limited thereto.

[0024] The memory controller 120 can use multiple channels ch 1 Toch m The memory controller 120 sends and receives signals to and from the memory device 104. More specifically, the memory controller 120 may write data to the NAND memory N 11 To N mn and from NAND memory N 11 To N mn Therefore, the memory controller 120 can read data through the channel ch 1 Toch m Commands, addresses, and data are sent to the memory device 104 , or data are received from the memory device 104 .

[0025] The memory controller 120 can use the channel ch 1 Toch m The corresponding channels in the selection are connected to the channel ch 1 Toch m Each NAND memory N 11 To N mn , and transmits data to the selected NAND memory and receives signals from the selected NAND memory. For example, the memory controller 120 may be connected to the first channel ch 1 NAND memory N 11 To N 1n Select NAND memory N 11 , to write data into NAND memory N 11 Therefore, NAND memory N 11 To N mn Each NAND memory in may include multiple "n" level cell blocks for storing data. 11Data is stored in "n" levels of cell blocks (such as single-level cell (SLC) blocks, multi-level cell (MLC) blocks, triple-level cell (TLC) blocks, quad-level cell (QLC) blocks, penta-level cell (PLC) blocks, etc.), where "n" represents the number of bits of data that can be stored in one cell block. Thus, SLC blocks store 1 bit per cell block, MLC blocks store 2 bits per cell block, TLC blocks store 3 bits per cell block, QLC blocks store 4 bits per cell block, PLC blocks store 5 bits per cell block, and so on. It will be noted that each NAND memory may include a specific type of cell block (e.g., QLC cell blocks), or may include a combination of cell blocks (e.g., QLC cell blocks, TLC cell blocks, MLC cell blocks, and SLC cell blocks) and is beyond the scope of the present disclosure.

[0026] In one example embodiment, the NAND memory N 11 One or more NAND latches 110 may be included. As will be described in detail later, one or more NAND latches 110 are used to accelerate the NAND memory NAND latch. 11 It should be noted that although one or more NAND latches are only depicted as being in the NAND memory N 11 However, any other NAND memory 12 To N mn Such one or more NAND latches may also be configured to speed up read / write operations within the corresponding NAND memory.

[0027] The memory controller 120 may send signals to and receive signals from the memory device 104 in parallel through different channels. For example, the memory controller 120 may send signals to and receive signals from the memory device 104 through the second channel ch 2 Send a command CMDb (not shown) to write data into the NAND memory N 22 At the same time, through the first channel ch 1 Send a command CMDa (not shown) to write data into the NAND memory N 11 In this way, the memory controller 120 can control all operations of the memory device 104. The memory controller 120 can send a signal to the channel ch 1 Toch m , and the control is connected to channel ch 1 Toch m NAND memory N 11 To N mn For example, the memory controller 120 may send a command CMDa and an address ADDRa (not shown) to the first channel ch 1 , and controls the NAND memory N 11 To N1n One NAND memory selected. It should be noted that the disclosure will be explained hereinafter with reference to writing / reading with respect to a single NAND memory, and writing / reading in other NAND memories follows a similar method and should not be construed as limiting the present disclosure.

[0028] In one example scenario, a host device associated with host controller 130 may intend to store data, and thus, host controller 130 may write the data to a NAND memory (eg, NAND memory N 11 ). More specifically, the host controller 130 may identify an "n" level cell block in the NAND memory to write data. For example, the host controller 130 identifies a QLC block that can store data. In this way, the host controller 130 performs a two-pass method to write data into the QLC cell of the NAND memory. This method for writing data into the NAND memory N 11 The two-pass method in the QLC cell of the present invention requires a large amount of additional resources (i.e., data buffer) to store the firmware structure and data, and therefore it is difficult to adopt the existing host controller with limited memory (TCM, SRAM, DRAM of the system, etc.). It should be noted that the host controller 130 as used herein refers to the controller of a device (e.g., a computer).

[0029] Various example embodiments of the present disclosure provide a method for writing data to an "n" level cell block of a NAND memory by a memory controller 120. More specifically, the memory controller 120 uses a set of support cell blocks within the NAND memory to write data to the "n" level cell block. Typically, a mapping defines an association between the set of support cell blocks and the "n" level cell block. In addition, the L2P table is updated based on the mapping to indicate the physical address of the data stored in the QLC. The host controller 130 writes the data to the set of support cell blocks, and the memory controller 120 performs a copyback operation from the set of support cell blocks based on the L2P table to write the data to the "n" level cell block. This technique of the memory controller 120 reduces the resource consumption required (or optionally, used) by the host controller 130 to write data to a higher level cell block of the NAND memory, thereby improving the performance and operating speed of the NAND device. In addition, based on checking the status of the write request, a read request from the host controller 130 is served from the appropriate location of the NAND memory (i.e., from the support cell block / "n" level cell block). Next, refer to Figure 2 Various operations of the memory controller 120 for writing and reading data to and from an “n” level cell block are described.

[0030] Figure 2A memory controller 120 for writing data to / reading data from a cell of a NAND memory according to an example embodiment of the present disclosure is shown. In one example embodiment, the memory controller 120 is an independent processor capable of managing read / write requests in the memory device 104. In another example embodiment, the memory controller 120 and the memory device 104 may be implemented as separate semiconductor chips that are operably coupled to each other to write data to / read data from a cell of a NAND memory. Alternatively, in some example embodiments, the memory controller 120 and the memory device 104 may be integrated in the same semiconductor chip.

[0031] As used herein, the term "support cell block" refers to a group of "n" level cell blocks that can be used as an intermediary for writing data to another "n" level cell block. For example, 4 SLC blocks can be used to write data to a QLC block, and thus, the 4 SLC blocks are referred to as "support cell blocks". More specifically, these "n" level cell blocks are free blocks in the NAND memory and can be used to write data received from the host controller 130. In other words, these free cell blocks are not currently programmed with data and are therefore concentrated in a free block pool to facilitate writing data to the "n" level cell blocks.

[0032] The memory controller 120 is depicted as including a processor 202, a memory 204, and a communication interface 208. It should be noted that in some example embodiments, the memory controller 120 may include more or fewer components than those depicted herein. The various components of the memory controller 120 may be implemented using hardware, software, firmware, or any combination thereof. Furthermore, the various components of the memory controller 120 may be operably coupled to each other. More specifically, the various components of the memory controller 120 may be capable of communicating with each other using a communication channel medium such as a bus, an interconnect, etc.

[0033] In an example embodiment, the processor 202 may be implemented as a multi-core processor, a single-core processor, or a combination of one or more multi-core processors and one or more single-core processors. For example, the processor 202 may be implemented as one or more of various processing devices (such as a coprocessor, a microprocessor, a controller, a digital signal processor (DSP), a processing circuit system with or without an accompanying DSP, or various other processing devices (including a microcontroller unit (MCU), a hardware accelerator, a dedicated computer chip, etc.)).

[0034] In one example embodiment, the memory 204 can store machine executable instructions (referred to herein as instructions 205). In one example embodiment, the processor 202 is implemented as an executor of software instructions. As such, the processor 202 can execute the instructions 205 stored in the memory 204 to perform one or more operations described herein. Figures 2 to 6 In detail, the memory 204 can be any type of storage device that the processor 202 can access to perform corresponding functions. For example, the memory 204 may include one or more volatile memories, or non-volatile memories, or a combination thereof. For example, the memory 204 can be implemented as a semiconductor memory (such as flash memory, mask ROM, PROM (programmable ROM), EPROM (erasable PROM), RAM (random access memory), etc.).

[0035] In addition, the memory 204 stores a logical to physical (L2P) table 206. The L2P table 206 includes a mapping from a logical address in the NAND memory to a physical address. The logical address is used by the host controller 130 to address the NAND memory. For example, the L2P table 206 includes a mapping between a logical address of the NAND memory and a physical page number (PPN) of the NAND memory. The L2P table 206 stores all logical to physical pointer data so that the host device can interact with the NAND-based SSD. When the host controller 130 intends to read data, the processor 202 will look up the physical address in the L2P table 206 to obtain the requested data. When the host controller 130 writes data to the NAND memory (e.g., an "n" level cell block), the L2P table 206 will be updated.

[0036] In an example embodiment, the processor 202 is configured to execute instructions 205 for: (1) updating the L2P table 206 based on a mapping between a group of support cell blocks and the "n" level cell block, and (2) performing a copy-back operation on the group of support cell blocks based on the L2P table 206 to write data to the "n" level cell block. In addition, when the processor 202 receives a read request for reading data from the "n" level cell block, the processor 202 is configured to execute instructions 205 for: (1) checking whether the "n" level cell block of the NAND memory is listed in the active block list, (2) based on determining that the "n" level cell block of the NAND memory is listed in the active block list, obtaining a mapping between the group of support cell blocks and the "n" level cell block, (3) obtaining data from at least one support cell block in a group of support cell blocks associated with the "n" level cell block based on the mapping, (4) based on determining that the "n" level cell block is not in the active block list, obtaining data from the "n" level cell block, and (5) providing the data to the host controller 130.

[0037] In an example embodiment, the communication interface 208 may include a mechanism configured to communicate with other entities (such as the memory device 104, the host controller 130) using different communication protocols. In this way, the host controller 130 can request information related to the free support cell blocks in the NAND memory from the memory controller 120. As used herein, the term "free support cell block" means an idle "n" level cell block. In other words, the "n" level cell block without written data is called an idle support cell block. The memory controller 120 can organize the information related to these idle support cell blocks in the idle support cell block pool and share it with the host controller 130.

[0038] In one example scenario, the host controller 130 intends to write data into the NAND memory, for example, the host controller 130 intends to write data into an "n" level cell block (such as a PLC block) to write the data. Then, the host controller 130 identifies a group of support cell blocks that can be associated with the "n" level cell block from a pool of free support cell blocks so as to write the data into the "n" level cell block. In one example embodiment, the host controller 130 may include a set of predefined (or optionally, desired) rules for allocating the group of support cell blocks to write data into the "n" level cell block. In one example, the predefined (or optionally, desired) rules may indicate that at least three support cell blocks may be allocated for writing data into the PLC. In another example, the predefined (or optionally, desired) rules may indicate that only SLC blocks may be allocated and mapped to write data into the QLC block. It should be noted that the predefined (or optionally, desired) rules described herein are for example purposes, and the predefined (or optionally, desired) rules may take any form that can be specified for efficiently writing data into the NAND memory.

[0039] In one example, 5 SLC blocks may be allocated and mapped to the PLC block to write data to the PLC block. In another example, 1 TLC block and 1 MLC block may be allocated and mapped to the PLC block to write data to the PLC block. It should be noted that the "n" level cell blocks from the free cell block pool and a group of support cell blocks from the free support cell block pool may be identified based on multiple parameters (such as but not limited to the size of the data, the data type, the number of P / E cycles, etc.). In an example embodiment, the memory controller 120 may provide data related to the free support cell block pool to the host controller 130. The host controller 130 may also identify the group of support cell blocks from the free support cell block pool.

[0040] Thus, the communication interface 208 is configured to receive a write request from the host controller 130 for writing data to the NAND memory. In an example embodiment, the host controller 130 sends the write request to the memory controller 120. The write request from the host controller 130 includes: data to be written from the group of support cell blocks of the NAND memory to the "n" level cell blocks of the NAND memory, and information about the mapping between the group of support cell blocks and the "n" level cell blocks. The mapping of the group of support cell blocks of the NAND memory to the "n" level cell blocks of the NAND memory indicates that the group of support cell blocks is associated with the "n" level cell blocks to write data to the "n" level cell blocks. More specifically, the mapping includes information about the mapping from each page of each support cell block to the corresponding page in the "n" level cell block. For example, if 1 MLC block and 1 SLC block are associated with 1 TLC block, the mapping may indicate that data is written from page 1 of the MLC to page 1 of the TLC, from page 2 of the MLC to page 2 of the TLC, and from page 1 of the SLC to page 3 of the TLC. The group of support unit blocks is located in a plurality of free support unit blocks in a pool of free support unit blocks. It should be noted that the information included in the write request is indicated for exemplary purposes, and the write request may include other additional information (e.g., a logical address of data in the host controller 130, one or more read / write rules defined by the host controller 130 for writing data, etc.). Figure 3A An example of mapping an "n" level cell block to a set of supporting cell blocks is shown and described.

[0041] Now refer to Figure 3A , shows an example representation 300 of a quad-level cell (QLC) block 302 for writing data to a NAND memory according to an example embodiment of the present disclosure. As already explained, when the host controller 130 intends to write data to the NAND memory, the host controller 130 identifies an "n" level cell block from a pool of free blocks and allocates a set of supporting cell blocks to write the data to the "n" level cell block.

[0042] In this example representation, a set of support cell blocks 304a, 304b, 304c, and 304d (i.e., 4 SLCs) are allocated for writing data to the QLC block 302. It should be noted that the 4 SLC blocks 304a, 304b, 304c, and 304d are shown for example purposes only, and the number of support cell blocks and the type of support cell blocks allocated for the QLC block 302 may vary based on the type of data, the size of the data, the availability of support cell blocks, etc. The host controller 130 also performs mapping of each support cell block in the set of support cell blocks 304a, 304b, 304c, and 304d to the QLC block 302. More specifically, each SLC block (i.e., SLC blocks 304a, 304b, 304c, and 304d) is mapped to a physical page number (PPN) of the QLC block 302. This ensures that data is written to the appropriate QLC block 302. The host controller 130 allocates and performs mapping of the group of support unit blocks 304a, 304b, 304c, and 304d for the QLC block 302. Figure 3B Another example of allocating and mapping a set of support unit blocks to a QLC block 302 is shown and described.

[0043] Now refer to Figure 3B , shows an example representation 350 of writing data to a quad-level cell (QLC) block 302 of a NAND memory according to another example embodiment of the present disclosure. In this example representation, the host controller 130 allocates 2 support cell blocks to write data to the QLC block 302. For example, 1 TLC block 352 and 1 SLC block 354 are allocated and mapped to the QLC block 302. As such, the PPN of the TLC block 352 and the PPN of the SLC block 354 will be mapped to the QLC block 302. It will be clear to those skilled in the art that any number of support cell blocks and different types of support cell blocks may be used to write data to a higher level cell block in order to improve the efficiency of write operations in a resource-constrained host controller 130. The set of support cell blocks (i.e., 304a, 304b, 304c, 304d or 352, 354) and the "n" level cell block (i.e., 302) are in the active block list based on the mapping. In other words, the map indicates that these cell blocks are allocated for writing data and are not available for any further read / write operations. Typically, the active block list provides information about non-free "n" level cell blocks and non-free supporting cell blocks.

[0044] Return to reference Figure 2, the processor 202, in conjunction with the instructions 205 in the memory 204, is configured to write data to the set of supporting cell blocks based on the mapping. More specifically, the data received from the host controller 130 as part of the write request is written to the supporting cell blocks based on the mapping. The processor 202 is also configured to update the L2P table 206 based on the mapping between the set of supporting cell blocks and the "n" level cell blocks. More specifically, the L2P table 206 is updated to indicate the physical address in the "n" level cell block where the data is to be stored (e.g., the physical address of the QLC block 302). It should be noted that during a write operation, the physical address of the supporting cell block is not stored in the L2P table 206. Since the physical address of the "n" level cell block to which the data must be written is updated in the L2P table 206, this eliminates the need for frequent updates to the L2P table 206.

[0045] In an example embodiment, the processor 202, in conjunction with the instructions 205 of the memory 204, is configured to: perform a copy-back operation on the group of supporting cell blocks based on the L2P table 206 using one or more NAND latches to write data to the "n" level cell block. As used herein, the term "copy-back" refers to internal data movement within the NAND memory. More specifically, during a copy-back operation, the memory controller 120 reads data from one location in the NAND memory and writes the data to another location in the NAND memory. For example, data is read from SLC blocks 304a, 304b, 304c, and 304d and written to QLC block 302 (see Figure 3A ) is referred to as a copy-back operation. As such, the memory controller 120 performs the internal data movement, and the host controller 130 is not involved as in the two-pass method.

[0046] In this way, a copy-back operation is performed on the group of supporting cell blocks to read the data present in each supporting cell block in the group of supporting cell blocks and write the data to the "n" level cell block. More specifically, one or more NAND latches 110 (see Figure 1) reads data from each page of each support cell block based on the mapping and writes data from each page of each support cell block into the corresponding page of the "n" level cell block. As already explained, the NAND latch is used to speed up the data read / write operation within the NAND memory. In this way, one or more NAND latches help copy back from the group of support cell blocks to the "n" level cell block inside the NAND memory. Such a technique for writing data into the "n" level cells of the NAND memory eliminates the need for a large number of data buffers in the host controller 130. In addition, since the copy back operation is performed inside the NAND memory, the resources of the host controller 130 are not used in large quantities, so that the existing host controller of the host device and the memory controller of the NAND memory can be used to write data to a higher level cell block (e.g., a PLC block / QLC block) using the support cell blocks.

[0047] Figure 4 A sequence flow chart 400 is shown for writing data into a cell of a NAND memory 402 according to an example embodiment of the present disclosure. Figure 4 When a host device (not shown) intends to store data in the NAND memory 402, a write request is generated. It should be noted that the host controller 130 may be configured within the host device or operably coupled to the host device to facilitate writing / reading of data to / from the NAND memory 402. In addition, the NAND memory 402 and the host controller 130 may be configured within a single device (e.g., a computer). Alternatively, the NAND memory 402 including the memory controller 120 may be a separate entity, and the host controller 130 of the host device may be configured to communicate with the memory controller 120 to read / write data in the NAND memory 402.

[0048] At 404, the host controller 130 allocates a set of supporting cell blocks in the "n" level cell blocks of the NAND memory 402 for writing data. More specifically, when there is data to be stored in the NAND memory 402, the host controller 130 analyzes the data and the free block pool to identify the "n" level cell blocks into which the data can be written. More specifically, the "n" level cell blocks into which the data can be written can be identified taking into account the data size, data type, and other parameters or predefined (or optionally, desired) rule sets. Therefore, as referenced FIG. 3A to FIG. 3B As illustrated, the host controller 130 selects a set of supporting cell blocks based on the identified "n" level cell blocks.

[0049] At 406, the host controller 130 maps the group of support cell blocks to the "n" level cell blocks. More specifically, the physical page of each support cell block in the group of support cell blocks is mapped to the physical page of the "n" level cell block to indicate the location where the data must be written to the "n" level cell block. Such mapping of the group of support cell blocks to the "n" level cell blocks ensures that the data is written to the correct memory location.

[0050] At 408, the host controller 130 updates the active block list and the free block list. The active block list includes information about non-idle "n" level cell blocks and non-idle support cell blocks. Non-idle "n" level cell blocks and non-idle support cell blocks include cell blocks to which the memory controller 120 has written data or cell blocks to which the memory controller 120 is currently writing data. Since these cell blocks are not available for storing data, they are in the active block list. The free block list includes information about free "n" level cell blocks and free support cell blocks. More specifically, support cell blocks and "n" level cell blocks that do not store data are in the free block list, which indicates that these cell blocks can be used to store data.

[0051] At 410, the host controller 130 generates a write request. The write request includes data and information about the mapping between the group of supporting cell blocks and the "n" level cell blocks. More specifically, the write request from the host controller 130 indicates to the memory controller 120 "write the data present in a group of supporting cell blocks of the NAND memory 402 to the "n" level cell blocks of the NAND memory 402".

[0052] At 412, the host controller 130 sends a write request to the memory controller 120. Therefore, the memory controller 120 writes the data to the set of supporting cell blocks before writing the data to the "n" level cell blocks (see 414).

[0053] At 416, the memory controller 120 updates the L2P table 206. More specifically, the L2P table 206 is updated with the physical page number in the "n" level cell block in which the data is written. In other words, the L2P table 206 is updated based on the mapping. However, it should be noted that only the PPN of the "n" level cell block of the NAND memory 402 is updated in the L2P table 206, and the PPN of the group of supporting cell blocks in which the data is initially written based on the mapping is not updated. This ensures that the L2P table 206 is not updated frequently.

[0054] At 418, the memory controller 120 writes the data into the "n" level cell block. More specifically, the memory controller 120 performs a copy-back operation on the group of supporting cell blocks to copy the data present in the group of supporting cell blocks back to the "n" level cell block.

[0055] At 420, the memory controller 120 sends a status update to the host controller 130. When the data is written to the "n" level cell block, the memory controller 120 sends a status update indicating "write operation complete" to the "n" level cell block.

[0056] At 422, the host controller 130 deallocates the set of support cell blocks associated with the "n" level cell block. More specifically, after the copy-back operation, the set of support cell blocks is disassociated from the "n" level cell block and is located in a pool of free support cell blocks. The "n" level cell block with data is moved from the active block list to the user block pool. The user block pool includes information about all "n" level cell blocks storing data.

[0057] At 424, the host controller 130 updates the active block list and the free block list. In some example embodiments, the host controller 130 may query the memory controller 120 at defined time intervals to receive information related to the active block list and the free block list. It should be noted that the memory controller 120 may also store the active block list and the free block list that are provided to the host controller 130 upon request.

[0058] Now refer to Figure 2 The communication interface 208 of the memory controller 120 is configured to receive a read request from the host controller 130 to read data from the "n" level cell block of the NAND memory. The read request may include a logical address corresponding to "at least one physical address of the NAND memory from which data must be obtained".

[0059] The processor 202 is configured to obtain data for the host controller 130 in conjunction with the instructions 205 of the memory 204. Therefore, the processor 202 is configured to check whether the "n" level cell block of the NAND memory is listed in the active block list. As already explained, the active block list includes information about non-idle "n" level cell blocks and non-idle support cell blocks. Thus, if the "n" level cell block is listed in the active block list, it indicates that data is currently being written to the "n" level cell block from the group of support cell blocks. In such a scenario, the memory controller 120 may not be able to obtain data from the "n" level cell block. For example, since a write operation is currently being performed on the "n" level cell block, the "n" level cell block may include only a fragment of the data (for example, a QLC block in which data is written will only have 2 bits of data instead of all the data (i.e., 4 bits)).

[0060] In an example embodiment, the processor 202 is configured to obtain a mapping between the group of support cell blocks and the "n" level cell blocks based on determining that the "n" level cell block of the NAND memory is listed in the active block list. Since the data has not yet been completely written to the "n" level cell block, the data will exist in the group of support cell blocks. The mapping provides information about the group of support cell blocks associated with the "n" level cell block, and the appropriate group of support cell blocks is identified according to the mapping. The processor 202 is also configured to obtain data from at least one support cell block in the group of support cell blocks associated with the "n" level cell block. More specifically, at least one support cell block is identified from the group of support cell blocks based on the mapping and the read request. For example, if the read request includes a logical address corresponding to only one PPN of the "n" level cell block (e.g., PLC), the mapping is used to identify the PPN of the support cell block corresponding to the PPN of the "n" level cell block. The data obtained from the PPN of at least one support cell block is provided to the host controller 130 to service the read request.

[0061] In another example embodiment, the memory controller 120 retrieves data from the "n" level cell block based on determining that the "n" level cell block is not in the active block list. If the data has been written to the "n" level cell block, the "n" level cell block is moved from the active block list to the user block pool. In such a scenario, the memory controller 120 is configured to perform a lookup of the L2P table 206 and identify the PPN of the "n" level cell block to read the data. It should be noted that the execution of the reference Figures 2 to 4 Any NAND memory described for writing data into an "n" level cell block performs the read operation described above. Figure 5 A method for writing data into a cell of a NAND memory is described.

[0062] Figure 5 is a flowchart illustrating a method 500 for writing data into a cell of a NAND memory according to an example embodiment of the present disclosure. The method 500 depicted in the flowchart may be performed by, for example, referring to Figures 2 to 4 The method 500 is shown and described as being performed by the processor 202 of the memory controller 120. The operations of the flowchart and combinations of the operations in the flowchart may be implemented by different means, such as hardware, firmware, a processor, a circuit system, and / or associated with the execution of software including one or more computer program instructions. The operations of the method 500 are described herein with reference to the processor 202 of the memory controller 120. The method 500 begins at operation 502.

[0063] At operation 502 of method 500, a memory controller (e.g., referring to Figures 2 to 4The memory controller 120 shown and described receives a write request from the host controller 130, the write request being used to write data present in a set of support cell blocks of the NAND memory into an "n" level cell block of the NAND memory. The write request includes information about the mapping between the set of support cell blocks and the "n" level cell block.

[0064] At operation 504 of method 500 , a logical-to-physical (L2P) table is updated based on a mapping between the set of supporting cell blocks and the “n” level cell blocks.

[0065] At operation 506 of method 500, a copy-back operation is performed on the group of supporting cell blocks based on L2P table 206 using one or more NAND latches to write data to the "n" level cell block. Figure 6 A method of servicing a read request from a cell in a NAND memory is described.

[0066] Figure 6 6 is a flowchart illustrating a method 600 for reading data from a cell in a NAND memory according to an example embodiment of the present disclosure. The method 600 depicted in the flowchart may be performed by, for example, referring to Figures 2 to 5 The method 600 is performed by the memory controller 120 shown and described. The operations of the flowchart and combinations of the operations in the flowchart may be implemented by different means, such as hardware, firmware, a processor, a circuit system, and / or associated with the execution of software including one or more computer program instructions. The operations of the method 600 are described herein with the aid of the processor 202 of the memory controller 120. The method 600 begins at operation 602.

[0067] At operation 602 of method 600, a memory controller (e.g., referring to Figures 2 to 4 The memory controller 120 shown and described receives a read request from the host controller 130, the read request being for reading data from an "n" level cell block of the NAND memory.

[0068] At operation 604 of method 600, the memory controller 120 checks whether the "n" level cell block of the NAND memory is listed in the active block list. The active block list includes information about non-idle "n" level cell blocks and non-idle support cell blocks. The "n" level cell block in the active block list indicates that data is being written to the "n" level cell block.

[0069] At operation 606 of method 600, when it is determined that the "n" level cell block of the NAND memory is listed in the active block list, a mapping between the group of supporting cell blocks and the "n" level cell block is obtained. If the "n" level cell block is listed in the active block list, data is obtained from at least one supporting cell block in the group of supporting cell blocks where data exists based on the read request and the mapping.

[0070] At operation 608 of method 600, data is retrieved from at least one supporting cell block in a set of supporting cell blocks associated with the "n" level cell block based on the mapping. The data is provided to the host controller 130. If the "n" level cell block is not in the active block list, data is retrieved from the "n" level cell block based on the L2P table 206.

[0071] The sequence of operations of method 500 / 600 does not necessarily need to be performed in the same order as the order in which they are presented. In addition, one or more operations may be grouped together and performed in the form of a single step, or an operation may have several sub-steps that may be performed in parallel or in a sequential manner.

[0072] Reference Figure 5 and Figure 6 One or more operations of the disclosed method or the flowchart depicted by the method 500 / 600 may be implemented using software comprising computer executable instructions stored on one or more computer readable media (e.g., non-transitory computer readable media (such as, one or more optical media disks), volatile memory components (e.g., DRAM or SRAM), or non-volatile memory or storage components (e.g., hard drives or solid-state non-volatile memory components (such as flash memory components))) and executed on a computer (e.g., any suitable computer (such as, a laptop, netbook, netbook, tablet computing device, smart phone or other mobile computing device)). For example, such software may be executed on a single local computer.

[0073] Figure 7 A block diagram of a general purpose computer for performing read-write operations in a NAND memory according to an example embodiment of the present disclosure is shown. Computer system 700 may include a central processing unit ("CPU" or "processor") 702. Processor 702 may include at least one data processor. Processor 702 may include a special processing unit (such as an integrated system (bus) controller, a memory management control unit, a floating point unit, a graphics processor, a digital signal processor, etc.). Computer system 700 may be similar to ( Figure 2 ) memory controller 120 shown in FIG.

[0074] The processor 702 may be configured to communicate with one or more input / output (I / O) devices (not shown) via the I / O interface 701. The I / O interface 701 may employ a communication protocol / method such as, but not limited to, audio, analog, digital, mono, RCA, stereo, IEEE-1394, serial bus, universal serial bus (USB), infrared, PS / 2, BNC, coaxial, component, composite, digital video interface (DVI), high-definition multimedia interface (HDMI), radio frequency (RF) antenna, S-Video, VGA, IEEE 802.n / b / g / n / x, Bluetooth, cellular (e.g., code division multiple access (CDMA), high-speed packet access (HSPA+), global system for mobile communications (GSM), long-term evolution (LTE), WiMax, etc.), etc.

[0075] The computer system 700 can communicate with one or more I / O devices using the I / O interface 701. For example, the input device 710 can be an antenna, a keyboard, a mouse, a joystick, an (infrared) remote control, a camera, a card reader, a fax machine, a dongle, a biometric reader, a microphone, a touch screen, a touch pad, a trackball, a stylus, a scanner, a storage device, a transceiver, a video device / source, etc. The output device 711 can be a printer, a fax machine, a video display (e.g., a cathode ray tube (CRT), a liquid crystal display (LCD), a light emitting diode (LED), a plasma, a plasma display panel (PDP), an organic light emitting diode display (OLED), etc.), an audio speaker, etc.

[0076] In some example embodiments, the computer system 700 is connected to a remote device 712 via a communication network 709. The remote device 712 may be a peripheral device (such as a solid-state device (e.g., memory device 104)) that communicates with the memory controller 120 to read / write data. The processor 702 may be configured to communicate with the communication network 709 via a network interface 703. The network interface 703 may communicate with the communication network 709. The network interface 703 may employ a connection protocol (including but not limited to direct connection, Ethernet (e.g., twisted pair 10 / 100 / 1000Base T), transmission control protocol / Internet protocol (TCP / IP), token ring, IEEE802.11a / b / g / n / x, etc.). The communication network 709 may include but not limited to direct interconnection, a local area network (LAN), a wide area network (WAN), a wireless network (e.g., using a wireless application protocol), the Internet, etc. Using the network interface 703 and the communication network 709, the computer system 700 may communicate with the remote device 712. The network interface 703 may employ a connection protocol (including but not limited to direct connection, Ethernet (e.g., twisted pair 10 / 100 / 1000Base T), Transmission Control Protocol / Internet Protocol (TCP / IP), Token Ring, IEEE 802.11a / b / g / n / x, etc.).

[0077] The communication network 709 includes, but is not limited to, direct interconnection, e-commerce networks, peer-to-peer (P2P) networks, local area networks (LANs), wide area networks (WANs), wireless networks (e.g., using wireless application protocols), the Internet, Wi-Fi, 3GPP, etc. The communication network 709 may include a first network and a second network (not shown). The first network and the second network may be dedicated networks or shared networks, where the shared network represents an association of different types of networks that communicate with each other using various protocols (e.g., Hypertext Transfer Protocol (HTTP), Transmission Control Protocol / Internet Protocol (TCP / IP), Wireless Application Protocol (WAP), etc.). In addition, the first network and the second network may include various network devices (including routers, bridges, servers, computing devices, storage devices, etc.).

[0078] In some example embodiments, the processor 702 may be configured to communicate with the memory 705 (eg, Figure 7The storage interface 704 may communicate with the memory 705 using a connection protocol such as Serial Advanced Technology Attachment (SATA), Integrated Drive Electronics (IDE), IEEE-1394, Universal Serial Bus (USB), Fibre Channel, Small Computer System Interface (SCSI), etc. The memory 705 includes but is not limited to a memory drive, a removable disk drive, etc. The memory drive may also include a DRAM, a disk drive, a magneto-optical drive, an optical drive, a redundant array of independent disks (RAID), a solid-state memory device, a solid-state drive, etc.

[0079] The memory 705 may store a collection of program or database components, including but not limited to a user interface 706, an operating system 707, a network server 708, etc. In some example embodiments, the computer system 700 may store user / application data (such as data, variables, records, etc.) as described in the present disclosure. Such a database may be implemented as a fault-tolerant, relational, scalable, secure database (such as, or ).

[0080] Operating system 707 may assist in resource management and operation of computer system 700. Examples of operating systems include, but are not limited to, APPLE OS X, UNIX-like distributions (e.g., BERKELEY SOFTWARE DISTRIBUTION TM (BSD), FREEBSD TM , NETBSD TM 、OPENBSD TM etc.), LINUX DISTRIBUTIONS TM (For example, RED HAT TM 、UBUNTU TM 、KUBUNTU TM etc.), IBM TM OS / 2, MICROSOFT TM 、WINDOWS TM (XP TM VISTA TM / 7 / 8 / 10, etc.), iOS TM , ANDROID TM , OS, etc.

[0081] In some example embodiments, computer system 700 may implement program components stored by network server 708. Network server 708 may be a hypertext viewing application (e.g., INTERNET EXPLORER TM , CHROME TM , FIREFOX TM , SAFARI TM Secure web browsing can be provided using secure hypertext transfer protocol (HTTPS), secure socket layer (SSL), transport layer security (TLS), etc. The web server 708 can use AJAX TM , DHTML TM 、ADOBER FLASH TM 、JAVASCRIPT TM , JAVA TM , application programming interface (API), etc. In some example embodiments, the computer system 700 may implement a program component stored in a mail server. The mail server may be an Internet mail server (such as Microsoft Exchange, etc.). The mail server may utilize a server such as ASP. TM 、ACTIVEX TM , ANSI TM C++ / C#, .NET TM 、CGI SCRIPTS TM , JAVA TM 、JAVASCRIPT TM PERL TM , PHP TM 、PYTHON TM 、WEBOBJECTS TM The mail server can use communication protocols such as Internet Message Access Protocol (IMAP), Messaging Application Programming Interface (MAPI), exchange, Post Office Protocol (POP), Simple Mail Transfer Protocol (SMTP), etc.). In some example embodiments, computer system 700 may implement a program component stored in a mail client. A mail client may be a mail viewing application (such as, MAIL TM , ENTOURAGE TM , OUTLOOK TM , THUNDERBIRDTM wait).

[0082] In addition, one or more computer-readable storage media may be used to implement example embodiments consistent with the present disclosure. A computer-readable storage medium represents any type of physical memory on which information or data readable by a processor can be stored. Thus, a computer-readable storage medium may store instructions for execution by one or more processors (including instructions for causing one or more processors to perform steps or stages consistent with the example embodiments described herein). The term "computer-readable medium" should be understood to include tangible items and exclude carrier waves and transient signals, i.e., non-transitory. Examples include random access memory (RAM), read-only memory (ROM), volatile memory, non-volatile memory, hard drives, CD (compact disk) ROMs, DVDs, flash drives, disks, and any other known physical storage media.

[0083] Various example embodiments of the present disclosure provide many advantages. Example embodiments of the present disclosure provide methods and systems for performing read operations and write operations in cells of NAND memory. Read / write operations using support cell blocks eliminate the need for a large number of additional resources and user data buffers in the host controller for storing firmware structures, thereby ensuring that the existing host controller 130 / memory controller 120 is easily used to perform read / write operations in higher-level cell blocks. In other words, the existing memory controller design can be used to perform read / write operations using higher-level cell blocks (such as QLC, PLC, "X" LC, etc.) without restrictions on SRAM, TCM, DRAM budgets at any time. In addition, the SLC block as a support cell block is highly reliable, and the internal read by performing a copy-back operation from the support cell block to the "n" level cell block will not have any errors during the internal data movement from the SLC block to the "n" level cell block (e.g., QLC block / PLC block). In addition, the copy-back operation is performed immediately after the data is written to the group of support cell blocks, so there is no impact on the SLC block from any other reliability issues (such as RD / retention / temperature changes, etc.). Furthermore, the internal copy-back acceleration using NAND latches helps reduce 2 direct memory access (DMA) operations to pull data out to DRAM and back to NAND memory, thereby saving power and speed. Additionally, updating the L2P table 206 with the physical address of the "n" level cell block avoids multiple updates to the L2P table 206. Furthermore, the disclosed read / write operations can be extended to other future "n" level cell blocks while maintaining the same architecture of the memory controller 120.

[0084] Those skilled in the art will understand that, in general, the terms used herein are generally intended to be "open" terms (e.g., the term "including" should be interpreted as "including but not limited to", the term "having" should be interpreted as "having at least", the term "comprising" should be interpreted as "including but not limited to", etc.). For example, to aid understanding, the detailed description may contain the use of the introductory phrases "at least one" and "one or more" to introduce statements. However, even when the introductory phrases "one or more" or "at least one" and an indefinite article such as "a" or "an" (e.g., "a" and / or "an" should generally be interpreted as meaning "at least one" or "one or more") are included in a statement, the use of these phrases should not be interpreted as implying that a statement introduced by the indefinite article "a" or "an" limits any particular part of the description that contains such introduced statement to the invention containing only one such statement; the same applies to the use of the definite article used to introduce such a statement. Additionally, even if specific portions of an introduced descriptive recitation are explicitly recited, those skilled in the art will recognize that such recitation should generally be interpreted to mean at least the recited quantity (e.g., a simple recitation of "two recitations" without other modifiers generally means at least two recitations or two or more recitations).

[0085] Any of the elements and / or functional blocks disclosed above may include a processing circuit system (such as hardware including a logic circuit; a hardware / software combination (such as a processor that executes software) or a combination thereof) or be implemented in a processing circuit system (such as hardware including a logic circuit; a hardware / software combination (such as a processor that executes software) or a combination thereof). For example, the memory controller 120, the host controller 130, and the processor 202 may be implemented as a processing circuit system. The processing circuit system may specifically include, but is not limited to, a central processing unit (CPU), an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a system on a chip (SoC), a programmable logic unit, a microprocessor, an application specific integrated circuit (ASIC), etc. The processing circuit system may include an electronic component (such as at least one of a transistor, a resistor, a capacitor, etc.). The processing circuit system may include an electronic component (such as a logic gate (including at least one of an AND gate, an OR gate, a NAND gate, a NOT gate, etc.)).

[0086] One or more processors, one or more controllers and / or processing circuit systems may be configured to perform actions or steps by being specifically programmed to perform the actions or steps (such as, utilizing an FPGA or ASIC), or may be configured to perform the actions or steps, or a combination thereof, by executing instructions received from a memory.

[0087] Although various aspects and exemplary embodiments have been disclosed herein, other aspects and exemplary embodiments will be apparent to those skilled in the art. The various aspects and exemplary embodiments disclosed herein are for purposes of illustration and are not intended to be limiting, with the true scope and spirit being indicated by the appended claims.

Claims

1. A method for writing data into a cell of a NAND memory, the method include: receiving, by a memory controller of the NAND memory from a host controller, a write request for writing data present in a set of support cell blocks of the NAND memory into an "n" level cell block of the NAND memory, wherein the write request includes information about a mapping between the set of support cell blocks and the "n" level cell block; updating, by the memory controller, a logical-to-physical table based on a mapping between the set of supporting cell blocks and the "n" level cell blocks; and A copy-back operation is performed by a memory controller on the set of supporting cell blocks based on a logical-to-physical table using one or more NAND latches to write data to the "n" level cell block.

2. The method according to claim 1, in, The “n” level cell block is one of: a multi-level cell block, a three-level cell block, a four-level cell block, and a five-level cell block.

3. The method according to claim 1, in, The group of support unit blocks is among the idle plurality of support unit blocks.

4. The method according to claim 3, in, The plurality of supporting cell blocks include one or more of: a single-level cell block, a multi-level cell block, a triple-level cell block, a quad-level cell block, and a penta-level cell block.

5. The method according to any one of claims 1 to 4, in, The set of supporting unit blocks and the “n” level unit blocks are listed in an active block list based on the mapping, wherein the active block list provides information on non-idle “n” level unit blocks and non-idle supporting unit blocks.

6. The method according to any one of claims 1 to 4, in, After the copy-back operation, the set of supporting unit blocks is located in a pool of free supporting unit blocks.

7. A method for reading data from a cell in a NAND memory, the method include: A memory controller of the NAND memory receives a read request from a host controller, the read request being used to read data from an "n" level cell block of the NAND memory; checking, by a memory controller, whether the "n" level cell block of the NAND memory is listed in an active block list, wherein the active block list includes information about non-idle "n" level cell blocks and non-idle support cell blocks; Based on determining that the "n" level cell block of the NAND memory is listed in the active block list, obtaining, by the memory controller, a mapping between a set of supporting cell blocks and the "n" level cell block; and Data is retrieved by a memory controller from at least one support cell block in the set of support cell blocks associated with the "n" level cell block based on the mapping, wherein the data from the at least one support cell block is provided to a host controller.

8. The method according to claim 7, in, Based on determining that the "n" level unit block is not in the active block list, data is obtained from the "n" level unit block based on the logical to physical table.

9. The method according to claim 7 or claim 8, in, The at least one support unit block is identified from the set of support unit blocks based on the mapping and the read request.

10. A memory controller for writing data into a cell of a NAND memory, the memory controller include: a memory configured to store instructions; as well as A processor configured to execute instructions stored in the memory and cause the memory controller to: receiving a write request from a host controller, the write request being for writing data present in a set of supporting cell blocks of a NAND memory into an "n" level cell block of the NAND memory, wherein the write request includes information about a mapping between the set of supporting cell blocks and the "n" level cell block, updating a logical-to-physical table based on a mapping between the set of supporting cell blocks and the "n" level cell blocks, and A copy-back operation is performed on the set of supporting cell blocks based on a logical-to-physical table using one or more NAND latches to write data into the "n" level cell block.

11. The memory controller according to claim 10, in, The “n” level cell block is one of: a multi-level cell block, a three-level cell block, a four-level cell block, and a five-level cell block.

12. The memory controller according to claim 10, in, The processor is configured to execute instructions stored in the memory so that the group of support unit blocks are among the idle plurality of support unit blocks.

13. The memory controller according to claim 12, in, The plurality of supporting cell blocks include one or more of: a single-level cell block, a multi-level cell block, a triple-level cell block, a quad-level cell block, and a penta-level cell block.

14. The memory controller according to any one of claims 10 to 13, in, The processor is configured to execute instructions stored in the memory so that the set of support unit blocks and the "n" level unit blocks are listed in an active block list based on the mapping, wherein the active block list provides information about non-idle "n" level unit blocks and non-idle support unit blocks.

15. The memory controller according to any one of claims 10 to 13, in, The processor is configured to execute instructions stored in the memory such that after the copy-back operation, the set of support unit blocks are located in a pool of free support unit blocks.