Adaptive error correction codes for data storage systems

Abstract

A data storage system configured to adaptively code data is disclosed. In one embodiment, a data storage system controller determines a common memory page size, such as an E-page size, for a non-volatile memory array. Based on the common memory page size, the controller selects a low-density parity-check (LDPC) code word length from a plurality of pre-defined LDPC code word lengths. The controller determines LDPC coding parameters for coding data written to or read from the memory array based on the selected LDPC code word length. By using the plurality of pre-defined LDPC code word lengths, the data storage system can support multiple non-volatile memory page formats, including memory page formats in which the common memory page size does not equal any LDPC code word length of the plurality of pre-defined LDPC code word lengths. Flexibility and efficiency of data coding can thereby be achieved.

Description

BACKGROUND

Technical Field

This disclosure relates to data storage systems, such as solid state drives, for computer systems. More particularly, the disclosure relates to adaptive error correction codes for data storage systems.

Description of the Related Art

Non-volatile memory arrays often have limited endurance. The endurance of the memory array is typically contingent on usage pattern and wear. In addition, endurances depend on a particular type of the non-volatile memory array. For example, memory arrays with multi-level cell (MLC) NAND media typically have a lower endurance than memory arrays with single-level cell (SLC) NAND media. To protect user data stored to memory arrays from corruption, which may be caused by a diminished endurance, parity data can be determined and stored along with user data to facilitate error detection and/or correction.

BRIEF DESCRIPTION OF THE DRAWINGS

Systems and methods that embody the various features of the invention will now be described with reference to the following drawings, in which:

FIG. 1 illustrates a storage system that adaptively codes data according to one embodiment of the invention.

FIG. 2 is a flow diagram illustrating a process of determining coding parameters for coding data according to one embodiment of the invention.

FIG. 3 is a table illustrating relationships between low-density parity-check (LDPC) coding parameters and LDPC code word lengths according to one embodiment of the invention.

FIGS. 4A-4C are diagrams illustrating padded user data and parity data according to one embodiment of the invention.

FIG. 5 is a flow diagram illustrating a process of adaptive code shortening according to one embodiment of the invention.

FIG. 6 is a flow diagram illustrating a process of adjusting a code rate according to one embodiment of the invention.

DETAILED DESCRIPTION OF SPECIFIC EMBODIMENTS

While certain embodiments are described, these embodiments are presented by way of example only, and are not intended to limit the scope of protection. Indeed, the novel methods and systems described herein may be embodied in a variety of other forms. Furthermore, various omissions, substitutions, and changes in the form of the methods and systems described herein may be made without departing from the scope of protection.

In some embodiments, “coding” or “to code” data as used in this disclosure refer to the process of encoding data and/or the process of decoding data.

Overview

Storage systems such as solid state drives typically include one or more controllers coupled with non-volatile memory arrays. It is commonplace for such controllers to be designed/manufactured by one party and the non-volatile memory arrays to be designed/manufactured by another party. In addition, memory arrays from different manufacturers tend to have different internal formatting, including different memory page formats, where each memory page format corresponds to one of multiple memory pages sizes. Also, for costs and various other competitive reasons, storage system manufacturers typically use memory arrays from different manufacturers. For example, a storage system manufacturer may use one brand of memory array in a current production cycle and another brand in the next production cycle. Also, different memory arrays may be used for different storage system models priced at different levels.

Therefore, one common design approach is to have storage systems include one or more controllers with multiple specialized hardware, firmware, and/or software that encode/decode data read from or written to the memory arrays from different manufacturers, with a subset of such hardware, firmware, and/or software actually used depending on the actual memory arrays paired with the controller(s) at time of assembly or at the final design stage. As a result, storage systems can include multiple controllers or extra, unused hardware, firmware, and/or software to support multiple memory page formats for the one or more memory arrays that are not included in the finally assembled storage systems.

In the alternative, to reduce the amount of hardware, firmware, and/or software included in storage systems, storage systems and controllers can be constructed to support only one specific, known memory page format having a known memory page size and may not to support other memory page formats. Such an approach, however, limits the usefulness of storage systems and controllers to other types of memory arrays, and multiple different storage systems and controllers may need to be constructed to support multiple memory array types. In addition, in some instances, a memory page format of a memory array may not be known when storage systems and controllers are designed/constructed. Accordingly, improved systems and methods for adaptively coding data for multiple known or unknown memory storage formats are desired.

In some embodiments of the present invention, a storage system includes a controller and a non-volatile memory array having a plurality of memory pages with a common memory page size. The controller determines the common memory page size for the non-volatile memory array and selects a code word length, such as a low-density parity-check (LDPC) code word length, from multiple pre-defined code word lengths based on the common memory page size. By selectively using an appropriate code word length (chosen from multiple pre-defined code word lengths) and corresponding coding parameters, the controller uses at least some common hardware, firmware, and/or software to support multiple known or unknown memory page formats. Thus, the controller can selectively adapt its operations, so it can be paired with memory arrays of different formats made by different manufacturers.

In some embodiments, a controller of a storage system adjusts coding parameters for coding user data as memory pages, blocks, or dies of the non-volatile memory array age and/or wear out due, in part, to use of the memory array. The mechanism of adjusting coding parameters enables the controller to support additional parity per unit data over time, thereby improving the error correction or detection capabilities as the quality (e.g., data retention capabilities) of the memory array diminishes. Moreover, the mechanism of adjusting coding parameters facilitates a balancing of decoding time due to additional parity per unit data with error correction or detection benefits of additional parity data. In addition, the controller can store adjusted coding parameters for memory pages, blocks, or dies of the memory array to permit different code or parity rates for different memory pages, blocks, or dies.

System Overview

FIG. 1 illustrates a storage system 120 that adaptively codes data according to one embodiment of the invention. As is shown, a storage system 120 (e.g., hybrid hard drive, solid state drive, etc.) includes a controller 130 and a non-volatile memory array 140, which comprises one or more blocks of storage, identified as Block “A” 142 through Block “N”. Each block comprises a plurality of flash pages (F-pages). For example, Block A 142 of FIG. 1 includes a plurality of F-pages, identified as F-pages A 153, B, through N. In some embodiments, each “F-page” is a smallest grouping of memory cells in the non-volatile memory array 140 that can be programmed in a single operation or as a unit. Further, each F-page includes a plurality of error correcting code pages (E-pages). In the illustrated embodiment, each F-page includes four E-pages that are illustrated as four boxes, including E-page 144. Other embodiments may use F-pages or E-pages that are defined differently or each F-page may include greater or fewer than four E-pages.

The controller 130 can receive data and/or storage access commands from a storage interface module 112 (e.g., a device driver) in a host system 110. Storage access commands communicated by the storage interface 112 can include write and read commands issued by the host system 110. The commands can specify a logical block address in the storage system 120, and the controller 130 can execute the received commands in the non-volatile memory array 140. In a hybrid hard drive, data may be stored in magnetic media storage component (not shown in FIG. 1) in addition to the non-volatile memory array 140.

The storage system 120 can store data received from the host system 110 so that the storage system 120 can act as memory storage for the host system 110. To facilitate this function, the controller 130 can implement a logical interface. The logical interface can present to the host system 110 storage system memory as a set of logical addresses (e.g., contiguous address) where data can be stored. Internally, the controller 130 can map logical addresses to various physical memory addresses in the non-volatile memory array 140 and/or other memory module(s).

The controller 130 includes a coder module 132. In one embodiment, the coder module 132 determines coding parameters for decoding/encoding data (e.g., user data) read from or written to memory pages, such as E-pages, of the non-volatile memory array 140. The coding parameters can be used for decoding user data read from the non-volatile memory array 140, encoding user data for storage to the non-volatile memory array 140, and other uses such as error detection or correction. The coding parameters can include LDPC coding parameters, such as the column weight of a G or H coding matrix, the row weight of a G or H coding matrix, a P matrix size (e.g., where the P matrix is a sub-matrix of a G or H coding matrix), and the like. Further, the coder module 132 can determine parity data for unpadded or padded user data, as well as decode user data having corresponding parity data and padding. In addition, the coder module 132 can adjust a code or parity rate for coding data by adjusting the coding parameters. The controller 130 and/or coder module 132 can further include internal memory (not shown), which may be of one or more suitable memory types.

The non-volatile memory array 140 can be implemented using NAND flash memory devices. Other types of solid-state memory devices can alternatively be used, such as array of flash integrated circuits, Chalcogenide RAM (C-RAM), Phase Change Memory (PC-RAM or PRAM), Programmable Metallization Cell RAM (PMC-RAM or PMCm), Ovonic Unified Memory (OUM), Resistance RAM (RRAM), NOR memory, EEPROM, Ferroelectric Memory (FeRAM), Magnetoresistive RAM (MRAM), other discrete NVM (non-volatile memory) chips, or any combination thereof. In one embodiment, the non-volatile memory array 140 preferably includes multi-level cell (MLC) devices having multi-level cells capable of storing more than a single bit of information, although single-level cell (SLC) memory devices or a combination of SLC and MLC devices may be used. In one embodiment, the storage system 120 can include other memory modules, such as one or more magnetic memory modules. The storage system 120 can further include other types of storage media, such as magnetic storage.

Adaptive Data Coding

FIG. 2 is a flow diagram illustrating a process 200 of determining coding parameters for coding data according to one embodiment of the invention. The process 200 can be executed by the controller 130 and/or the coder module 132. Advantageously, the process 200 can enable the controller 130 and/or the coder module 132 to support multiple non-volatile memory page formats using a plurality of code word lengths.

At block 205, the process 200 determines a memory page size for a non-volatile memory array, such as the non-volatile memory array 140. The memory page size can be, for instance, provided by the memory array vendor or calculated based on another known memory size. For example, the memory page size can correspond to an E-page size of the non-volatile memory array, and the process 200 can calculate the E-page size by looking-up a vendor provided F-page size of the memory array and dividing the F-page size by an appropriate constant for the non-volatile memory array, such as 4 or 8. In other embodiments, the memory page size can correspond to an F-page size.

At block 210, the process 200 selects a code word length that equals or exceeds the memory page size from a plurality of code word lengths. For example, the memory page size can be 2164 bytes or octets, and the plurality of pre-defined code word lengths can include lengths of 2176 bytes and 2304 bytes. In one embodiment, the process 200 selects the LDPC code word length having a minimum size or number of bytes of data equal to or greater than the memory page size from a plurality of pre-defined LDPC code word lengths. For example, the process 200 can select the code word length of 2176 bytes, which exceeds 2164 byte memory page size and has a minimum size of the plurality of pre-defined LDPC code word lengths.

At block 215, the process 200 determines coding parameters based at least in part on the selected code word length. The coding parameters can be used when coding data read from or written to the non-volatile memory array and enable the process 200 to manage a code rate (e.g., an amount of user data per total data of a data unit, where total data includes user data and parity data) for data. In one embodiment, the coding parameters for a LDPC code word length include a column weight, a P matrix size, and a row weight, and further include at least one of a code rate, an amount of user data, and an amount of parity data.

At block 220, the process 200 stores the coding parameters. For example, the process 200 can store the coding parameters in the non-volatile memory array 140 and/or in one or more other storage media of the storage system 120. The process 200 can store the coding parameters in internal memory of the controller 130 and/or the coder module 132. The stored coding parameters can facilitate using different coding parameters for coding different pages, blocks, or other divisions and/or subdivisions of the non-volatile memory array 140 and for tracking and adjusting coding parameters over time as portions of the non-volatile memory array age and/or wear out.

FIG. 3 is a table 300 illustrating relationships between LDPC coding parameters and LDPC code word lengths according to one embodiment of the invention. The table 300 can designate the LDPC code word lengths and LDPC coding parameters supported by a controller, such as the controller 130 and/or coder module 132. The table 300 can be stored in the non-volatile memory array 140, one or more other storage media of the storage system 120, and/or in the internal memory of the controller 130 and/or the coder module 132. The table 300 includes two code length columns indicating two supported LDPC code word lengths. One LDPC code word length equals 2176 bytes (2048+128·1 bytes), and the other LDPC code word length equals 2304 bytes (2048+128·2 bytes). It has been discovered that various code rates around 2 kbytes can provide an optimal trade-off between complexity and performance.

For each code length, the LDPC coding parameters of column weight, P matrix size, and row weight can be varied to enable coding of data using different designed code rates (e.g., different amounts of user data per total data of a data unit, where total data includes user data and parity data) as listed in table 300. For example, if the LDPC code word length equals 2176 bytes, the applied LDPC coding parameters can be one of the LDPC coding parameter sets at circles C1, C2, C3, or C4. In one instance, the LDPC coding parameters can be chosen at circle C3, which correspond to a column weight of 4, P matrix size of 512, and row weight of 34 and further to a code rate of 0.882 (1920 bytes of user data for 2176 byes of total code length). Further, in one embodiment, the code length, which may be defined as 2048+128×Δ, can be adjusted based on selecting Δ as 1, 2, etc. As is illustrated, selecting the value of Δ also affects the code rate. For example, at circle C1, selecting Δ to be 1 results in the code rate of 0.941, and if the column weight, P matrix size, and row weight remain unchanged, selecting Δ to be 2 results in the code rate of 0.944. As will be further explained, the various pre-defined code rates can be used to accommodate memory arrays of different page sizes. For example, as shown, the two code lengths of 2176 and 2304 bytes can accommodate page sizes of 2176 and 2304 bytes. It is to be noted that in practice the number of pre-defined code lengths can be much higher than two to accommodate various page sizes.

A controller supporting the LDPC coding parameters of table 300 can advantageously select one code length for a non-volatile memory array and adjust the LDPC coding parameters to code data at different code rates. For instance, when a memory array with an E-page size of 2176 bytes is relatively new (e.g., lightly used) and/or experiences or exhibits few coding errors, the LDPC coding parameters at circle C1 can be selected for coding data. The LDPC coding parameters at circle C1 correspond to a column weight of 4, P matrix size of 256, and row weight of 68 and further to a code rate of 0.941. A total of 128 bytes of parity can be used for coding 2048 bytes of data at circle C1. As memory pages, blocks, or dies of the memory array age and/or wear out, the LDPC coding parameters at circles C2, C3, and C4 can instead be selected for coding data. The controller can, accordingly, gradually increase the amount of parity per unit data from a code rate of 0.941 to codes rates of 0.926, 0.882, and 0.853 at circles C2, C3, and C4, respectively, in response to changes in the quality (e.g., loss of quality) of the non-volatile memory array.

Adaptive Code Shortening

Through adaptive code shortening, some embodiments of the invention can accommodate memory arrays with page sizes that do not match up exactly with the pre-defined code lengths. FIGS. 4A-4C are diagrams illustrating padded user data and parity data used in adaptive code shortening according to one embodiment of the invention. In particular, FIGS. 4A-4C illustrate how shortening may be used to adapt code word lengths to match the memory page size for a non-volatile memory array. Advantageously, shortening enables the controller 130 and/or coder module 132 to support a memory page format in which the memory page size does not equal any code word length of a plurality of pre-defined code word lengths. For instance, if the controller 130 and/or coder module 132 support pre-defined LDPC code word lengths equal to 2176 and 2304 bytes, shortening can be used so that the controller 130 and/or coder module 132 further support a memory page size of 2164 bytes. Moreover, shortening can permit the controller 130 and/or coder module 132 to adaptively code data to match the non-volatile memory array format without sacrificing a large bit error rate performance.

In one embodiment, shortening comprises three operations. First, padding data is added to the user data to be encoded. The padding data in one embodiment is sized to be the difference between the pre-defined code length and memory page size. Second, parity data is generated based on the padding and user data. Third, the user data and parity data, which add up to the memory page size, are stored in the memory page. The padding data is not stored, but will be appended to the user data upon decoding (e.g., when the user data and parity data is read out from the memory page at a later time).

FIG. 4A illustrates padding 410 and user data 420 of a data unit 400a. The user data 420 corresponds to an amount of user data for data unit 400a, and the padding 410 corresponds to a padding that facilitates code shortening. The padding 410 can include a data set of entirely zeros, entirely ones, etc., or any known or pre-defined data pattern. Continuing the example of the previous paragraph, if the memory page size is 2164 bytes for the non-volatile memory array, the controller 130 and/or coder module 132 can select, from various pre-defined code lengths such as those shown in table 300, the shortest LDPC code word length having a size equal to or greater than 2164 bytes. In this case, the code length of 2176 bytes is selected. The controller 130 and/or coder module 132 can determine that the padding 410 should include a data set having length that is equal to the difference between the code word length (2176) and the memory page size (2164) of the non-volatile memory array, or 2176−2164=12 bytes of padding data. Depending on the LDPC coding parameters for the data unit 400a, the controller 130 and/or coder module 132 can further determine an amount of bytes reserved for user data 420 and an appropriate G coding matrix for determining and/or generating parity data.

FIG. 4B illustrates an example encoding process according to one embodiment. In effect, the user data 420 is “padded” so that the combined user data and padding meet the amount of bytes reserved for user data in the chosen pre-defined code length. The parity 430 is then generated for the combined padding 410 and user data 420 of a data unit 400b. Continuing the example of the previous paragraph, the appropriate G coding matrix can be used to determine LDPC parity data for parity 430. Note that as described above, the actual distribution of the 2176 bytes between padding 410, user data 420, and parity data 430 may vary. The following table illustrates some of the possible configurations (all sizes in bytes):

Memory Page Size 2164 Bytes

Configuration	Code Length-2176
C1 (FIG. 3)	Reserved for User Data	Reserved for
		Parity
	2048	128
With	Padding	Actual User Data (FIG. 4-	Parity (FIG. 4-
Shortening	(FIG. 4-	420)	430)
Scheme	410)
	12	2036	128
Memory Page	Not written to	2164 (2036 + 128)
Size	memory

Memory Page Size 2164 Bytes

Configuration	Code Length-2176
C3 (FIG. 3)	Reserved for User Data	Reserved for
		Parity
	1920	256
With	Padding	Actual User Data (FIG. 4-	Parity (FIG. 4-
Shortening	(FIG. 4-	420)	430)
Scheme	410)
	12	1908	256
Memory Page	Not written to	2164 (1908 + 256)
Size	memory

FIG. 4C illustrates a data unit 400c, having user data 420 and parity 430 of the data unit 400b with padding 410 removed. The user data 420 and the parity 430 can be written to and subsequently read from a memory page of the non-volatile memory array 140. As shown in the tables above, the amount of user data 420 and parity data 430 can equal the memory page size of the non-volatile memory array, and the padding data is not written to the page. When the page is read out later, as part of the decoding, the padding is appended back to the user data read from the page. In this manner, coding for arbitrary page sizes can be performed using one of the plurality of pre-defined code word lengths at the cost of a small loss in coding efficiency.

FIG. 5 is a flow diagram illustrating a process 500 of adaptive code shortening according to one embodiment of the invention. The process 500 can be executed by the controller 130 and/or the coder module 132. Advantageously, the process 500 can enable the controller 130 and/or the coder module 132 to support memory page sizes that do not equal any code word length of a plurality of pre-defined code word lengths supported by the controller 130 and/or coder module 132. The process 500 can be used to construct and manage data units 400a, 400b, and 400c described in FIGS. 4A-4C.

At block 505, the process 500 receives user data. The user data can be received from the storage interface module 112 along with a write command to write the user data to a non-volatile memory array, such as the non-volatile memory array 140.

At block 510, the process 500 pads the user data with padding data. The padding data can include a data set of entirely zeros, entirely ones, or a known or pre-defined data pattern. In addition, at block 510, the process 500 can further divide the user data into units having a size equal to an amount of user per data unit, which depends on corresponding coding parameters. For example, if the non-volatile memory array has a memory page size equal to 2164 bytes and the LDPC coding parameters correspond to the parameters at circle C3 of FIG. 3, the user data can be divided into units having a size equal to 1908 bytes.

At block 515, the process 500 determines parity data for the padded user data using coding parameters. Continuing the example of the previous paragraph, if the LDPC coding parameters correspond to the parameters at circle C3, an appropriate G coding matrix can be selected and used to determine LDPC parity data for the padded user data.

At block 520, the process 500 outputs the user data and parity data. For example, the process 500 can output the user data and parity data for storage to E-page 144 of F-page 143 of the non-volatile memory array 140. It can be noted that the padding described with to respect to blocks 510 and 515 can be characterized as “virtual padding” since the padding itself may not be written to the memory page.

Code Rate Adjusting

FIG. 6 is a flow diagram illustrating a process 600 of adjusting a code rate according to one embodiment of the invention. The process 600 can be executed by the controller 130 and/or the coder module 132. Advantageously, the process 600 can enable the controller 130 and/or the coder module 132 to adjust the code rate (e.g., an amount of parity per unit data) of memory pages, blocks, or other divisions of a non-volatile memory array as the memory pages, blocks, or other divisions wear out and/or experience decreased quality.

At block 605, the process 600 reads user data and parity data stored in a memory page. For example, the process 600 can perform a read of F-page 143 in response to a read command from the host system 110.

At block 610, the process 600 detects a number of bit errors when decoding the user data using parity data and coding parameters. For instance, the process 600 can determine a number of detected bit errors when decoding the user data using stored parity data and LDPC coding parameters corresponding to the memory page.

At block 615, the process 600 determines whether the number of bit errors exceeds a bit error threshold. The bit error threshold can depend or vary based on the coding parameters for coding data to the memory page. For example, the bit error threshold for the LDPC coding parameters at circle C1 of FIG. 3 may be lower than the bit error threshold for the LDPC coding parameters at circle C2. If the process 600 determines that the number of bit errors does not exceed the bit error threshold, the process 600 terminates. On the other hand, if the process 600 determines that the number of bit errors exceeds the bit error threshold, the process 600 moves to block 620.

At block 620, the process 600 checks whether the coding parameters can be adjusted to reduce a code rate. In other words, the process 600 can determine whether more parity data can be used for coding. In one embodiment, the process 600 can determine whether the LDPC coding parameters may be adjusted while keeping a LDPC code word length unchanged. For instance, if E-page 144 is currently coded using the LDPC coding parameters at circle C3 of FIG. 3, the LDPC coding parameters can be adjusted to the parameters at circle C4. Alternatively, if E-page 144 currently is coded using LDPC coding parameters at circle C4 and the table 300 contains the only available LDPC coding parameters, the parameters may not be further adjusted to a lower code rate. If the process 600 determines that the coding parameters may not be adjusted to reduce the code rate, the process 600 terminates. On the other hand, if the process 600 determines that the coding parameters can be adjusted to reduce a code rate, the process 600 moves to block 625. In one embodiment, the change of code rate may be managed at a block level where the pages in the block are switched to a new code rate at the same time. In one embodiment, where MLC memory is used, upon a determination that a further reduced code rate cannot be used, rather than terminating the process 600, the page (or block of pages) may be configured to operate in a lower-page only mode.

At block 625, the process 600 adjusts the coding parameters and stores the adjusted coding parameters to reduce a code rate for a next write operation. The process 600 can store the adjusted coding parameters in the non-volatile memory array 140, other memory module of the storage system 120, and/or internal memory of the controller 130 and/or coder module 132. The process 600 can store an indication of the code rate or LDPC coding parameters for coding data to facilitate management of LDPC coding parameters on a memory page, block, or other level division of a non-volatile memory array. Further, the adjusted coding parameters can be used for coding user data associated with a subsequent write command received from the host system 110.

Other Variations

Those skilled in the art will appreciate that in some embodiments, other approaches and methods can be used. For example, the coding techniques disclosed herein can apply to codes besides LDPC codes, such as other iterative codes like turbo codes. In addition, although the coding parameters and other values disclosed in the table 300 of FIG. 3 illustrate an example set of relationships between coding parameters and code word lengths, other or additional coding relationships can be used. The table 300 can include column weights with values less than 4 and greater than 5 (such as 3 or 6), P matrix sizes with values less than 256 bits or greater than 512 (such as 128 or 1024), Δ values of less than 1 or greater than 2 (such as −1, 0, 3, or 4), Δ values having a corresponding granularity other than 128 bytes (such as 64 bytes), and a base code length with a value of less or greater than 2048 (such as 2176). Further, an amount of parity data in each data unit can be set to different values or varied depending on a quality of a storage medium. Additionally, quality metrics other than or in addition to bit errors can be used to determine whether to adjust coding parameters for coding data. Moreover, depending on the embodiment, certain of the steps described above may be removed, and others may be added. Accordingly, the scope of the present disclosure is intended to be defined only by reference to the appended claims.

While certain embodiments have been described, these embodiments have been presented by way of example only, and are not intended to limit the scope of the protection. Indeed, the novel methods and systems described herein may be embodied in a variety of other forms. Furthermore, various omissions, substitutions and changes in the form of the methods and systems described herein may be made without departing from the spirit of the protection. The accompanying claims and their equivalents are intended to cover such forms or modifications as would fall within the scope and spirit of the protection. For example, the systems and methods disclosed herein can be applied to hard disk drives, hybrid hard drives, and the like. In addition, other forms of storage (e.g., DRAM or SRAM, battery backed-up volatile DRAM or SRAM devices, EPROM, EEPROM memory, etc.) may additionally or alternatively be used. As another example, the various components illustrated in the figures may be implemented as software and/or firmware on a processor, ASIC/FPGA, or dedicated hardware. Also, the features and attributes of the specific embodiments disclosed above may be combined in different ways to form additional embodiments, all of which fall within the scope of the present disclosure. Although the present disclosure provides certain preferred embodiments and applications, other embodiments that are apparent to those of ordinary skill in the art, including embodiments which do not provide all of the features and advantages set forth herein, are also within the scope of this disclosure. Accordingly, the scope of the present disclosure is intended to be defined only by reference to the appended claims.

Claims

1. A data storage system, comprising: a non-volatile memory array comprising a plurality of memory pages; anda controller configured to:access coding parameters used to encode user data and parity data to be stored in the plurality of memory pages;encode, using the coding parameters, first user data and first parity data as a first data unit;store the first data unit in the plurality of memory pages;decode, using the coding parameters, the first data unit retrieved from the plurality of memory pages;detect a first number of bit errors encountered during decoding the first data unit retrieved from the plurality of memory pages;in response to determining that the first number of bit errors exceeds a first threshold, adjust the coding parameters to increase an amount of parity data per total data that is included in data units subsequently encoded and stored in the plurality of memory pages; andencode, using the adjusted coding parameters, second user data and second parity data as a second data unit to be stored in the plurality of memory pages.

2. The data storage system of claim 1, wherein the controller is further configured to: store the second data unit in the plurality of memory pages;decode, using the adjusted coding parameters, the second data unit retrieved from the plurality of memory pages;detect a second number of bit errors encountered during decoding the second data unit retrieved from the plurality of memory pages;in response to determining that the second number of bit errors exceeds a second threshold greater than the first threshold, modify the adjusted coding parameters to increase the amount of parity per total data that is included in the data units subsequently encoded and stored in the plurality of memory pages; andencode, using the modified coding parameters, third user data and third parity data as a third data unit to be stored in the plurality of memory pages.

3. The data storage system of claim 1, wherein the coding parameters comprise low-density parity-check (LDPC) coding parameters including a P matrix size and a column weight, and the controller is configured to adjust the coding parameters by changing at least one of the P matrix size and the column weight.

4. The data storage system of claim 1, wherein the controller is configured to access alternative coding parameters used to encode the user data and the parity data to be stored in a portion of the non-volatile memory array other than the plurality of memory pages, the alternative coding parameters being different from the coding parameters.

5. The data storage system of claim 1, wherein the controller is configured to adjust the coding parameters in response to determining that the first number of bit errors exceeds the first threshold and that a limit on the amount of parity per total data that is included in the data units has not been reached.

6. In a data storage system comprising a controller, a method of coding data, the method comprising: accessing coding parameters used to encode user data and parity data to be stored in a plurality of memory pages of a non-volatile memory array;encoding, using the coding parameters, first user data and first parity data as a first data unit;storing the first data unit in the plurality of memory pages;decoding, using the coding parameters, the first data unit retrieved from the plurality of memory pages;detecting a first number of bit errors encountered during decoding the first data unit retrieved from the plurality of memory pages;in response to determining that the first number of bit errors exceeds a first threshold, adjusting the coding parameters to increase an amount of parity data per total data that is included in data units subsequently encoded and stored in the plurality of memory pages; andencoding, using the adjusted coding parameters, second user data and second parity data as a second data unit to be stored in the plurality of memory pages.

7. The method of claim 6, further comprising: storing the second data unit in the plurality of memory pages;decoding, using the adjusted coding parameters, the second data unit retrieved from the plurality of memory pages;detecting a second number of bit errors encountered during decoding the second data unit retrieved from the plurality of memory pages;in response to determining that the second number of bit errors exceeds a second threshold greater than the first threshold, modifying the adjusted coding parameters to increase the amount of parity per total data that is included in the data units subsequently encoded and stored in the plurality of memory pages; andencoding, using the modified coding parameters, third user data and third parity data as a third data unit to be stored in the plurality of memory pages.

8. The method of claim 6, wherein the coding parameters comprise low-density parity-check (LDPC) coding parameters including a P matrix size and a column weight, and wherein said adjusting the coding parameters comprises changing at least one of the P matrix size and the column weight.