# Patent

## Title
Apparatuses and methods for encoding using error protection codes

## Abstract

Subject matter disclosed herein relates to error protection of data stored in and/or read from a memory device.

## Background
BACKGROUND
1. Field
Subject matter disclosed herein relates to error protection of data stored in and/or read from a memory device.
2. Information
Memory devices, which can include an array or arrays of memory cells, continue to become denser to provide increased storage capacity. However, as their memory cells become smaller, they may also tend to become more prone to errors. Errors occurring during reading and/or writing of a nonvolatile memory may result from storage charge loss, random telegraph signal effects, coupling effects, de-trapping mechanisms, read disturb phenomena, and/or cosmic rays, just to name a few examples. Such may occur for a number of nonvolatile memory technologies like NAND Flash Memories, NOR Flash Memories, and/or Phase Change Memory. In addition, error probability may increase for memories utilizing multi-level architecture to store data (e.g., code, instructions, or any other information) in a memory cell. Here, a voltage (and/or current) window may remain largely the same but a read and/or write margin may decrease because signal levels may be relatively close together, for example. Techniques to address potential memory errors remain desirable.



BRIEF DESCRIPTION OF THE FIGURES
Embodiments of claimed subject matter are illustrated by way of example and not by way of limitation in the figures of the accompanying drawings, in which:
FIG. 1 is a schematic diagram of an embodiment of an arrangement of memory devices;
FIG. 2 is a schematic diagram of an embodiment for iteratively generating parity data from program data;
FIG. 3 is a schematic diagram of an embodiment for computing parity data from program data and coefficient data;
FIGS. 4-6 are schematic diagrams of embodiments of parity generation circuits;
FIG. 7 is a flow diagram of an embodiment of a process to compute coefficient data representing K coefficients; and
FIG. 8 is a schematic diagram illustrating an embodiment of a computing system.



DETAILED DESCRIPTION
In the following detailed description, reference is made to the accompanying figures that show, by way of illustration, specific embodiments of claimed subject matter. These embodiments are described in sufficient detail to enable those skilled in the art to practice claimed subject matter. It is to be understood that the various embodiments of claimed subject matter, although different, are not necessarily mutually exclusive. For example, a particular feature, structure, and/or characteristic described herein in connection with one embodiment may be implemented within other embodiments of claimed subject matter. In addition, it is to be understood that the location and/or arrangement of individual components within a disclosed embodiment may be modified. The following detailed description is, therefore, not to be taken in a limiting sense, and subject matter for the present application is determined by the issued claims, appropriately interpreted, along with the full range of equivalents to which the claims are entitled. In the drawings, like numerals refer to the same and/or similar aspects throughout the several views.
Some portions of the following description are presented in terms of logic, algorithms, and/or symbolic representations of operations on data stored within an apparatus, such as a memory (e.g., stored bits, such as stored logical signal values), whether alone or as part of a system, such as a special-purpose computing device and/or platform. In the context of the specification, the term “specific system” and/or the like includes a general-purpose computing device once it is programmed to perform particular functions pursuant to instructions from program software. Algorithmic descriptions and/or symbolic representations are examples of techniques used by those of ordinary skill in the art in the data processing and/or related arts to convey the substance of their work to others skilled in the art. An algorithm is here, and generally, considered to be a self-consistent sequence of operations and/or similar processing leading to a desired result. In this context, operations and/or processing involve manipulation of physical properties. Manipulation includes a change in a physical property of a memory cell such that the memory cell is to be programmed to a particular data state (e.g., a state representing a logic “1” and/or a state representing a logic “0”). Manipulation also includes a change in a physical property of a data signal (e.g., an acoustic, electrical, magnetic, and/or optical signal) used to combine, communicate, compare, store, transform and/or otherwise manipulate data to be programmed into and/or read from one or more memory cells. It has proven convenient at times, principally for reasons of common usage, to refer to data signals and/or data states as data (e.g., bits, values, elements, symbols, characters, terms, numbers, numerals, and/or the like). It should be understood, however, that all of these and/or similar terms are to be associated with the appropriate physical properties, and/or corresponding measurements thereof and, therefore, are merely convenient labels.
Unless stated otherwise, as apparent from the following discussion, it is appreciated that throughout the specification, discussions utilizing terms such as “processing,” “computing,” “determining,” “detecting,” “flagging,” “designating,” “setting,” “assigning,” “generating,” “storing”, and/or the like may refer to actions and/or processes of an apparatus (e.g., a memory device or other specific apparatus, such as a special purpose computer and/or similar special-purpose computing device). In the context of this specification, therefore, a special-purpose computer and/or a similar special-purpose computing device is capable of, for example, manipulating data, such as that in the form of data signals and/or data states.
Embodiments of claimed subject matter may include methods and/or apparatuses (e.g., an individual apparatus or a combination of apparatuses or components thereof) for performing operations. An apparatus may be specially constructed for desired purposes and/or an apparatus may comprise a general-purpose computing device capable of operating in accordance with a computer program stored in memory. A program may be stored in memory, such as, but not limited to, any type of disk including floppy disks, optical disks, compact disc read only memories (CD-ROMs), magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), nonvolatile memories such as electrically programmable read-only memories (EPROMs), electrically erasable and programmable read only memories (EEPROMs) and/or FLASH memories, phase change memories (PCM) and/or any other type of media suitable for storing electronic instructions.
A memory typically may be non-transitory and/or comprise a non-transitory device. In this context, a non-transitory memory may include a device that is tangible, meaning that the device has a concrete physical form, although the device may change its physical state. Thus, for example, non-transitory refers to a device remaining tangible despite this change in state.
In describing embodiments of claimed subject matter, the term “bit” corresponds to a binary digit of data, such as represented by a state of a binary digital data signal, which is sometimes also referred to as a logic signal, a binary signal, a logic state, or a binary state. The value of a bit, a fraction of a bit, or multiple bits may be stored by programming a memory cell, such as a single transistor, for example, to one of a plurality of data states. For example, in a single level memory cell, the cell might be programmed to a first (e.g., logic 1) data state or a second (e.g., logic 0) data state. Additionally, multiple binary digital data signals and/or multiple data states comprising individual binary digital data signals and/or data states may be organized and/or aggregated to construct (e.g., assemble) a “symbol,” which may collectively represent, for example, two bits, four bits, eight bits, 10 bits, and so forth. In one example, a 2-bit symbol may have a value of 00, 01, 10, or 11. In some cases, a single memory cell may be selectively programmed to a respective data state representing any one of those values. For example, a 00 value for a 2-bit symbol may be stored by programming a memory cell to a respective one of four possible data states (e.g., corresponding to a respective range of threshold voltage levels). In a similar manner, a particular value of a 4-bit symbol (e.g., 0101) may be stored by programming one or more memory cells to a respective one of 16 possible data states, and a particular value of an 8-bit symbol (e.g., 0000 0110) may be stored by programming one or more memory cells to a respective one of 256 different data states, and so forth. Any of the foregoing symbols may be communicated as one or more measurable physical properties (e.g., an acoustic, current, radiation, and/or voltage level) of, for example, one or more data signals.
Further, a “codeword” may be stored as respective programmed data states of multiple memory cells (perhaps as many as 200 or more) representing program data (e.g., stored information or information to be stored), along with, for example, respective programmed data states of multiple memory cell states representing parity data, which may be used to detect and/or correct errors in the program data that may have potentially been introduced through various mechanisms. Embodiments of claimed subject matter may include an erasure flag that indicates that location(s) of one or more errors within a codeword are known and/or may be approximated. In the event that location(s) of one or more errors within a codeword are known or may be approximated, certain error protection codes (such as, for example, a Reed Solomon error protection code) may be capable of correcting perhaps as many as twice the number of errors that could be corrected if the location(s) of the one or more errors was or were otherwise unknown (although nothing herein should be interpreted as requiring or limiting embodiments of claimed subject matter to a particular coding technique). In this context, an error protection code refers to a code employed to detect and/or correct errors (ECC).
Memory may be employed in a variety of contexts. As an example, memory may be included in a computing system. In this context, the term computing system refers to at least a processor and memory coupled by a bus. Likewise, in this application, the terms memory, memory system, memory module, memory device and/or memory apparatus are used interchangeably unless the context of usage indicates otherwise. A memory cell, however, refers to a unit of storage within a memory and a memory array refers to an array of memory cells. It is understood that a memory, memory system, memory module, memory device and/or memory apparatus may also include other circuitry or components to enable use of the memory cells of the array, for example. Likewise, a memory subsystem refers to a sub-portion of a memory system. Although in FIG. 1, an encoder and/or decoder are illustrated as separate from a memory subsystem, FIG. 1 is merely provided for purposes of illustration. Therefore, in other embodiments or implementations, a memory subsystem, for example, may include an encoder and/or a decoder. Use of various types of memory, such as phase change memory and/or NAND flash, for example, may benefit by including an error protection capability. Error protection may allow retrieval of program data at acceptably low rates of errors in data read from memory by employing ECC techniques. ECC techniques may include a relatively broad class of codes, such as BCH codes (Bose, Chaudhuri, Hocquenghem), which may include Reed-Solomon and/or narrow-sense BCH subsets, for example.
FIG. 1 is a schematic diagram of an embodiment 100 of an apparatus in the form of an arrangement of memory devices, which may include an error protection capability. For example, embodiment 100 may comprise an arrangement of component memory devices (e.g., memory chips or dice) as arrays of devices that may be written (e.g., programmed) to and/or read from during memory operations. In this application, the terms written to and programmed may be used interchangeably unless the context of usage indicates otherwise. Likewise, programmed refers to storing any type of data, not merely storing code, for example. Memory operations, such as reading from memory cells and/or writing to memory cells, may take place concurrently, sequentially and/or in various combinations. In one implementation of embodiment 100, program data may be stored in (e.g., written into) memory subsystem 120. Memory subsystem 120 may comprise any number of memory devices 125. Program data, which may comprise multiple bits (e.g., 1's and/or 0's) of data, may have been generated by a processor executing an application, for example, and may be transmitted as signals from the processor to the memory device(s). An encoder, such as 110 may add error protection to program data being written to memory subsystem 120. For example, encoder 120 may produce one or more codewords to be provided to memory subsystem 120, such as during memory operations. Memory subsystem 120 may store one or more codewords to be read at a later time. In one example implementation, a codeword may comprise program data and parity data computed (e.g., generated) by a particular ECC implementation. However, a codeword read from memory devices 125, may be subject to imperfections such as those resulting in erroneous data values being read. A decoder 130 may identify and/or remove in accordance with the intended operation of the particular error protection scheme erroneous data from a codeword with errors and return originally written program data.
It may be desirable for an encoder (e.g., encoder 110) and/or a decoder (e.g., decoder 130) of an apparatus, such as that of embodiment 100, for example, to operate relatively fast using a relatively low level of logic complexity. For example, it may be difficult to design an encoder, such as a Reed-Solomon and/or narrow-sense BCH encoder, that achieves relatively high-speed throughput, low latency, and/or relatively low logic-circuit complexity. In one application, an apparatus may comprise a component of a memory hierarchy using non-volatile storage that operates as an adjunct or replacement for traditional dynamic random access memory (DRAM). In this or other applications, desirable memory performance may involve throughputs with magnitudes on the order of up to gigabytes per second and/or latencies with magnitudes on the order of tens of nanoseconds, for example. However, some embodiments may achieve this level of performance using an encoder, such as encoder 110, for example, capable of operating based, at least in part, on electronics comprising circuitry, such as combinational logic-function circuitry, for example.
In an embodiment, parity data may be computed based, at least in part, on program data and on coefficient data for an employed error protection code. Coefficient data may represent values referred to as “canonical coefficients.” In an embodiment, for example, coefficient data may be computed for an error protection code using a canonical form independent of program data, the computed coefficient data representing coefficients, such as canonical coefficients, employed to compute parity data from the program data. In this context, the term canonical form refers to a technique for representing coefficients employed to compute parity data from program data in which the coefficients are determined independent of the program data. In contrast, as described in more detail below, these coefficients are conventionally determined in a manner that is not independent of the program data.
In an implementation, coefficient data, e.g., representing canonical coefficients, as suggested above, may be computed for a particular type of error protection code independently of program data. Therefore, in an implementation, selection of a particular error code may, in effect, be applied to determine the coefficients. This feature may, therefore, in an implementation, allow for coefficient data representing canonical coefficients to be pre-computed by an apparatus before the apparatus is provided with program data, for example. For example, coefficient data may be pre-computed external to the apparatus and stored before program data is provided to an apparatus (e.g., a system or memory device).
Using coefficient data representing canonical coefficients to compute parity data may provide beneficial features for a particular implementation. For example, for a given type of error protection code, such computed coefficient data may be used (e.g., re-used) for different sets of program data stored in different memory arrays of a single memory device and/or different memory arrays of separate memory devices. For example, coefficient data may be stored in a look-up table of a memory device to be used to compute parity data for different sets of program data. Furthermore, using canonical coefficients permits computing parity data without necessarily using iterative calculations. Conventionally, an iterative process is employed to compute parity data. Computing parity data without iterative calculations suggests that calculations may be performed using combinational logic circuitry having relatively small size, low latency and/or low power compared with circuits to perform iterative calculations in an implementation, for example. In one embodiment, a size of combinational logic circuitry may be capable of being approximately linearly scaled with a number of parity bits that the combinational logic circuitry is to compute, for example.
FIG. 2 is a schematic diagram of an embodiment 200 for iteratively generating parity data from program data. Embodiment 200 may comprise a circuit to generate parity data, an example of which is shown in FIGS. 4 and 5, described below. FIG. 3 is a schematic diagram of an embodiment 300 for computing (e.g., generating) parity data from program data and coefficient data. For example, coefficient data may represent canonical coefficients in a particular embodiment.
In embodiment 200, program data 210 may be used in an iterative process 225 to compute parity data 220. For new program data, iterative process 225 is re-employed, consuming computational resources and adding latency. Also, the size of circuitry to perform a computation may increase more than linearly with the number of bits of program data, for example.
In contrast, referring to embodiment 300, process 325 may compute parity data 330 based, at least in part, on coefficient data 310 and program data 320. Coefficient data may represent canonical coefficients, which may be pre-computed if an error protection code has been identified, such as by an application, an external device or a user, for example. Embodiment 300 may comprise combinational logic components, for example, to execute process 325 of computing parity data 330. As mentioned above, coefficient data representing canonical coefficients, for example, may be used (e.g., re-used) for multiple sets of program data to compute parity data.
In accordance with claimed subject matter, an error protection technique may involve computing coefficient data (e.g., in the form of bits of data) representing coefficients, such as canonical coefficients, for a combinatorial encoder for a block oriented error protection code. A block oriented code in this context, refers to a code to transform a sequence, such as a message, which comprises program data, into a(nother) fixed-length sequence, comprising a codeword. As previously suggested, error protection may be added by transforming the message into a larger codeword to detect and/or correct errors, which with suitable decoding, may be employed to recover the initial message.
In an embodiment, an error protection technique may be performed by a circuit that computes parity data based, in part, on program data and on pre-computed coefficient data representing coefficients of an error protection code, such as canonical coefficients. In one implementation, coefficient data may be pre-computed by an iterative process. For example, “pre-computed” may refer to a time prior to presentation (e.g., in a memory system) of program data for which parity data is computed. In one implementation, the coefficient data may be computed (e.g., generated) at a source, such as a processor, for example, external to a memory device. In another implementation, an apparatus may allow a selection of error protection code, where the coefficient data may be computed responsive to the selection. For example, an application, an external device or a user, as examples, may select an error protection code. Therefore, some embodiments may comprise an apparatus capable of computing coefficient data, such as based in part on code selection.
In an embodiment, an error protection technique may be performed by parity computing circuit blocks to compute associated parity data for corresponding groups of program data. For example, circuit blocks may apply pre-computed canonical coefficients to one or more groups of program data. Pre-computed canonical coefficients may comprise coefficients computed at a time prior to presentation (e.g., in a memory system) of program data for which parity data is computed. Pre-computed canonical coefficients may therefore be independent of the groups of program data. Parity computing circuit blocks may, for example, operate in parallel. Of course, these are merely examples, and claimed subject matter is not so limited.
In an embodiment, relation 1 may be employed in parity encoding for a cyclic algebraic code. Of course, this is merely one approach. This approach, not to be considered limiting, however, may be useful for illustrative purposes. Relation 1 may be used for any bit size of program data and/or parity data, for example. Relation 1 may be valid for Reed-Solomon implementations as well as narrow-sense BCH, for example.




  
    
      
        
          
            ∑
            
              i
              =
              0
            
            
              n
              -
              k
              -
              1
            
          
          ⁢
          
            
              P
              i
            
            ⁢
            
              x
              i
            
          
        
        =
        
          mod
          [
          
            
              
                x
                
                  n
                  -
                  k
                
              
              ×
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    k
                    -
                    1
                  
                
                ⁢
                
                  
                    D
                    i
                  
                  ⁢
                  
                    x
                    i
                  
                
              
            
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  n
                  -
                  k
                
              
              ⁢
              
                
                  g
                  i
                
                ⁢
                
                  x
                  i
                
              
            
          
          ]
        
      
    
    
      
        [
        1
        ]
      
    
  




In relation 1, parity data of the form Pn−k−1, Pn−k−2, . . . P0 may be generated from a remainder polynomial P(x) resulting from a division of a program polynomial D(x)=Dk−1, Dk−2, . . . , D0 by a generator polynomial g(x)=xn−k+gk−1xn−k−1+, . . . , +g0x0, where Dk−1, Dk−2, . . . , D0 may comprise program data. If g(x) comprises a generator polynomial for a Reed Solomon code, for example, it has roots ∝m0+0, ∝m0+1, . . . , ∝m0+k−1 from some finite Galois field GF(2q), where m0 may comprise 0 and q may comprise size measured in bits. Here, n may comprise a number of bits of program and parity data and k may comprise a number of bits of parity data, both being positive integers.
The following example, which is not to be considered limiting, illustrates an n, k block code with n=8 and k=5. Relation 2 may illustrate an aspect of an encoding operation, for the example.




  
    
      
        
          
            
              P
              2
            
            ⁢
            
              x
              2
            
          
          +
          
            
              P
              1
            
            ⁢
            
              x
              1
            
          
          +
          
            
              P
              0
            
            ⁢
            
              x
              0
            
          
        
        =
        
          Rem
          ⁢
          
            
              
                x
                3
              
              ×
              
                [
                
                  
                    
                      D
                      4
                    
                    ⁢
                    
                      x
                      4
                    
                  
                  +
                  
                    
                      D
                      3
                    
                    ⁢
                    
                      x
                      3
                    
                  
                  +
                  
                    
                      D
                      2
                    
                    ⁢
                    
                      x
                      2
                    
                  
                  +
                  
                    
                      D
                      1
                    
                    ⁢
                    
                      x
                      1
                    
                  
                  +
                  
                    D
                    0
                  
                
                ]
              
            
            
              
                x
                3
              
              +
              
                
                  g
                  2
                
                ⁢
                
                  x
                  2
                
              
              +
              
                
                  g
                  1
                
                ⁢
                
                  x
                  1
                
              
              +
              
                gx
                0
              
            
          
        
      
    
    
      
        [
        2
        ]
      
    
  




In relation 2, program polynomial D4x4, D3x3, . . . , D0x0 may be divided by a generator polynomial x3+g2x2+g1x1+gx0 after scaling by xn−k, where n−k=3, for this example. A parity polynomial, P2x2+P1x1+P0x0, may comprise a remainder. In an embodiment, encoding may include combining polynomials, as illustrated by relation 3.

D4x7+D3x6+D2x5+D1x4+D0x3+P2x2+P1x1+P0x0  [3]

Di may represent data written to a memory system, such as that of embodiment 100, for example. Likewise, a read operation may retrieve the stored data, but many include distortions as a result physical processes encountered as a consequence of writing and/or reading. Relation 4, however, may enable decoding so that stored data may be identified and/or recovered correctly despite the presence of an error, for example. In relation 4, coefficients of the polynomial, R7, R6, . . . , R0, may comprise the values of data read from memory.

R7x7+R6x6+R5x5+R4x4+R3x3+R2x2+R1x1+R0x0  [4]

In an implementation, a decoding process may also include a calculation of syndromes. Relation 5 may illustrate a syndrome calculation, for example, for Reed-Solomon implementations.

Sj=R7(∝j)7+R6(∝j)6+R5(∝j)5+R4(∝j)4+R3(∝j)3+R2(∝j)2+R1(∝j)1+R0(∝j)0  [5]

For example, a substitution for x using a generator root ∝j, as shown, may be employed to do the calculation. Of course, these details are merely illustrative examples, and claimed subject matter is not so limited.

FIG. 4 illustrates an embodiment 400 of a circuit architecture that may be employed to calculate parity data from program data. For example, a linear feedback shift register may apply program data, such as D4, D3, . . . , D0, at 410. To obtain parity data P2, P1, P0, from five bits of program data, for example, may involve five iterations, in which a respective bit of the program data is entered on an iteration, for example. Storage elements 430, as a result of circuit architecture, contain P2, P1, P0 after the five iterations have occurred. Embodiment 400 may be less desirable for some situations since the iterations may constrain throughput and/or latency, for example.
FIG. 5 illustrates an embodiment 500 of a circuit architecture that may be employed to calculate parity data from program data without performing iterations. Instead, successive calculations may be cascaded through levels of combinational logic circuitry in an embodiment. However, circuit architecture, such as embodiment 500, may be relatively large as a result. Complexity may rise disproportionally with number of bits of data to be processed. Furthermore, due at least in part to the nature of the calculation being performed, some paths of the architecture may produce “bottlenecks,” resulting in potential circuit delay.
FIG. 6 illustrates an embodiment 600 of a circuit architecture that may reduce circuit delay and/or circuit complexity compared with embodiments 400 and 500, for example. As illustrated, embodiment 600 may comprise a circuit architecture having smaller complexity for a given type of error code, as well as a relatively high throughput and/or relatively low latency. Parity data may be generated by a sum of products having a combinational logic structure of embodiment 600. Program data D4, D3, . . . , D0, continuing with the previous example, are provided and coefficients, such as canonical coefficients, for example, may be employed. A sum of products, as illustrated for an embodiment, may therefore compute parity data. Embodiment 600 may involve a Reed Solomon or a narrow-sense BCH parity calculation, for example. In a narrow-sense BCH calculation, a symbol may comprise a single bit in size. Multiplication and addition operations may comprise binary calculations (e.g., from GF(2)). In a Reed Solomon configuration, calculations may be realized with symbols of size q (e.g., q>3) with multiplication and addition operations performed over a finite field GF(2q). Of course, embodiment 600 is merely an example, and claimed subject matter is not limited to this particular architecture.
FIG. 7 is a flow diagram of an embodiment of a process 700 to compute (e.g., generate) coefficient data representing canonical coefficients. As explained above, canonical coefficients may be used to compute parity data, such as illustrated by embodiment 600, for example. Though process 700 may involve an iterative process, process 700 need not involve program data. Coefficients, therefore, may be computed independently of program data to provide canonical coefficients. At block 710, initialization of process 700 may include initializing parameters such as n and/or k. For example, n may comprise 8 and k may comprise 5. Field parameters may comprise parameters for use in arithmetic operations. For example, multiplication tables may be stored to perform arithmetic in a finite field of interest. At block 710, i, j, and m may be set to zero. These parameters may operate as index values. For example, with k=5, possible values of i may comprise 0 through 4. In this example, j may comprise from 0 to one less than the number of roots of a generator polynomial, e.g., 0 . . . (n−k−1). In this example, m may index program data (k), so possible values for m may include values in the range 0 . . . (k−1).
At block 720, a determination may be made as to whether j is equal to zero. If so, process 700 may proceed to block 730 for a “yes” result or to block 740 for a “no” result. At block 730, a determination may be made as to whether i is equal to m. Consequently, a canonical coefficient may be assigned a value according to block 735 if “yes” and according to block 738 if “no.” At block 740, a determination may be made as to whether i is equal to m. Consequently, a canonical coefficient may be assigned a value according to block 745 if “yes” and according to block 748 if “no.” Thus, as a result of appropriate decision paths being resolved, coefficients may be calculated. In one particular implementation, canonical coefficients may be determined at blocks 735, 738, 745, and 748 according to relations 11a,b, for example, presented below. Of course, this is merely one example, and coefficient data may likewise be computed using other techniques and/or approaches.
After a calculation iteration, parameter indexes may be employed to continue to resolve appropriate decision paths. At block 750, if values of i and In are equal, an iteration of m has taken place. If so, process 700 may proceed to block 760. Otherwise, process 700 may proceed to block 755 where i may be incremented. At block 760, a determination may be made as to whether to proceed with another iteration of j by evaluating whether j is equal to n−k−1. If so, process 700 may proceed to block 770. Otherwise, process 700 may proceed to block 765 where j may be incremented and i may be assigned a zero value. At block 770, a determination may be made as to whether to proceed with another iteration of m by evaluating whether m is equal to (k−1). Equality between the values of m and (k−1) may indicate that a set of canonical coefficients have been calculated. This may mark an end point and exit from process 700 may take place. However, if m is still less than (k−1), process 700 may proceed to block 775 for another iteration, where values i, j, and m may be updated by resetting i and j to zero and incrementing a value of m. Process 700 may then return to block 720 for iteration.
A calculation of canonical coefficients is provided below for a specific example. Although claimed subject matter is not limited in scope to this example, an example calculation may be useful to demonstrate application of calculations illustrated by blocks 735, 738, 745 and 748.
A circuit architecture illustrated by embodiment 400 may likewise be useful in connection with an example calculation. For example, labels g0, g1, g2 may correspond to coefficients of a generator polynomial, for example. A feedback portion may therefore result in multiplication of a feedback signal, illustrated by circuit paths 440 and multiplier 425. Interim values P0(m), P1(m) and P2(m) may be calculated on successive iterations and stored in registers 430. For example, five bits of program data may produce five iterations in this example calculation. Prior to beginning an encoding sequence, registers 430 may be cleared to zero.
Introducing program data bit D4 at 410, registers 430 may be updated in accordance with the relations below.

P0(0)=g0D4  [6a]

K04(0)=g0  [6b]

P1(0)=g1D4  [6c]

K14(0)=g1  [6d]

P2(0)=g2D4  [6e]

K24(0)=g2  [6f]

f1=K24(0)+D3  [6g]

For example, 6a, 6c, and 6e may represent register data after iteration 0. A 0th iteration state may comprise a product of program data bit D4 multiplied by a respective generator polynomial coefficient. Relations 6b, 6d, and 6f therefore may comprise values of Kj,k−1−i|i=0 . . . m−1(m) at a 0th iteration. A feedback value may be given by relation 6g.

Likewise, 7a, 7d, and 7g may represent register data after iteration 1. 7b, 7c, 7e, 7f, 7h, and 7i may comprise Kj,k−1−i|i=0 . . . m−1(m) after iteration 1. Relation 7j may comprise a feedback value to be applied for the next iteration, for example.

P01=g0f1=g0K24(0)D4+g0D3  [7a]

K04(1)=g0K24(0)  [7b]

K03(1)=g0  [7c]

P1(1)=g1f1+K04(0)D4=[g1K24(0)+K04(0)]D4+g1D3  [7d]

K14(1)=g1K24(0)+K04(0),  [7e]

K13(1)=g1  [7f]

P2(1)=g2f1+K14(0)D4=[g2K24(0)+K14(0)]D4+g2D3  [7g]

K24(1)=g2K24(0)+K14(0),  [7h]

K23(1)=g2  [7i]

f2=K24(1)D4+K23(1)D3+D2  [7j]

Below are values for iteration 2.

P0(2)=g0f2=g0K24(1)D4+g0K23(1)D3+g0D2  [8a]

K04(2)=g0K24(1)  [8b]

K03(2)=g0K23(1)  [8c]

K02(2)=g0  [8d]

P1(2)=g1f2+K04(1)D4+K03(1)D3=g1[K24(1)D4+K23(1)D3+D2]+K04(1)D4+K03(1)D3=[g1K24(1)+K04(1)]D4+[g1K23(1)+K03(1)]D3+g1D2  [8e]

K14(2)=g1K24(1)+K04(1),  [8f]

K13(2)=g1K23(1)+K03(1),  [8g]

K12(2)=g1  [8h]

P2(2)=g2f2+K14(1)D4+K13(1)D3=g2[K24(1)D4+K23(1)D3+D2]+K14(1)D4+K13(1)D3  [8i]

K24(2)=[g2K24(1)+K14(1)],  [8j]

K23(2)=[g2K23(1)+K13(1)],  [8k]

K22(2)=g2  [8l]

f3=K24(2)D4+K23(2)D3+K22(2)D2+D1  [8m]

Below are values for iteration 3.

P0(3)=g0f3=g0K24(2)D4+g0K23(2)D3+g0K22(2)D2+g0D1  [9a]

K04(3)=g0K24(2),  [9b]

K03(3)=g0K23(2),  [9c]

K02(3)=g0K22(2),  [9d]

K01(3)=g0  [9e]





  
    
      
        
          
            
              
                P
                1
                
                  (
                  3
                  )
                
              
              =
              
              ⁢
              
                
                  
                    g
                    1
                  
                  ⁢
                  
                    f
                    3
                  
                
                +
                
                  
                    K
                    04
                    
                      (
                      2
                      )
                    
                  
                  ⁢
                  
                    D
                    4
                  
                
                +
                
                  
                    K
                    03
                    
                      (
                      2
                      )
                    
                  
                  ⁢
                  
                    D
                    3
                  
                
                +
                
                  
                    K
                    02
                    
                      (
                      2
                      )
                    
                  
                  ⁢
                  
                    D
                    2
                  
                
              
            
          
        
        
          
            
              =
              
              ⁢
              
                
                  
                    g
                    1
                  
                  ⁡
                  
                    [
                    
                      
                        
                          K
                          24
                          
                            (
                            2
                            )
                          
                        
                        ⁢
                        
                          D
                          4
                        
                      
                      +
                      
                        
                          K
                          23
                          
                            (
                            2
                            )
                          
                        
                        ⁢
                        
                          D
                          3
                        
                      
                      +
                      
                        
                          K
                          22
                          
                            (
                            2
                            )
                          
                        
                        ⁢
                        
                          D
                          2
                        
                      
                      +
                      
                        D
                        1
                      
                    
                    ]
                  
                
                +
              
            
          
        
        
          
            
              
              ⁢
              
                
                  
                    K
                    04
                    
                      (
                      2
                      )
                    
                  
                  ⁢
                  
                    D
                    4
                  
                
                +
                
                  
                    K
                    03
                    
                      (
                      2
                      )
                    
                  
                  ⁢
                  
                    D
                    3
                  
                
                +
                
                  
                    K
                    02
                    
                      (
                      2
                      )
                    
                  
                  ⁢
                  
                    D
                    2
                  
                
              
            
          
        
        
          
            
              =
              
              ⁢
              
                
                  
                    [
                    
                      
                        
                          g
                          1
                        
                        ⁢
                        
                          K
                          24
                          
                            (
                            2
                            )
                          
                        
                      
                      +
                      
                        K
                        04
                        
                          (
                          2
                          )
                        
                      
                    
                    ]
                  
                  ⁢
                  
                    D
                    4
                  
                
                +
                
                  [
                  
                    
                      
                        g
                        1
                      
                      ⁢
                      
                        K
                        23
                        
                          (
                          2
                          )
                        
                      
                    
                    +
                    
                      K
                      03
                      
                        (
                        2
                        )
                      
                    
                  
                  ]
                
                +
              
            
          
        
        
          
            
              
              ⁢
              
                
                  
                    [
                    
                      
                        
                          g
                          1
                        
                        ⁢
                        
                          K
                          22
                          
                            (
                            2
                            )
                          
                        
                      
                      +
                      
                        K
                        02
                        
                          (
                          2
                          )
                        
                      
                    
                    ]
                  
                  ⁢
                  
                    D
                    2
                  
                
                +
                
                  
                    g
                    1
                  
                  ⁢
                  
                    D
                    1
                  
                
              
            
          
        
      
    
    
      
        [
        
          9
          ⁢
          f
        
        ]
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              K
              14
              
                (
                3
                )
              
            
            =
            
              
                
                  g
                  1
                
                ⁢
                
                  K
                  24
                  
                    (
                    2
                    )
                  
                
              
              +
              
                K
                04
                
                  (
                  2
                  )
                
              
            
          
          ,
        
      
    
    
      
        [
        
          9
          ⁢
          g
        
        ]
      
    
  




K13(3)=g1K23(2)+K03(2),  [9h]

K12(3)=g1K22(2)+K02(2),  [9i]

K11(3)=g1  [9j]

P2(3)=g2f3+P1(2)=[g2K24(2)+K14(2)]D4+[g2K23(2)+K13(2)]D3+[g2K22(2)+K12(2)]D2+g2D1  [9k]

K24(3)=g2K24(2)+K14(2),  [9l]

K23(3)=g2K23(2)+K13(2),  [9m]

K22(3)=g2K22(2)+K12(2),  [9n]

K21(1)=g2  [9o]

f4=K24(3)D4+K23(3)D3+K22(3)D2+K21(3)D1+D0  [9p]

In the example, results of iteration 4, provided below, may comprise a final iteration. Accordingly, 10a, 10h, and 10n may represent values of parity data calculated for an example case of n=8 and k=3.

P0(4)=g0f4=g0K24(3)D4+g0K23(3)D3+g0K22(3)D2+g0K21(3)D1+g0D0  [10a]

K04(4)=g0K24(3),  [10b]

K03(3)=g0K23(3),  [10c]

K02(3)=g0K22(3),  [10d]

K02(3)=g0K21(3),  [10e]

K00(4)=g0  [10f]

P1(4)=g1f4+K04(3)D4+K03(3)D3+K02(2)D2+K01(2)D1=[g1K24(3)+K04(3)]D4+[g1K23(3)+K03(3)]D3+[g1K22(3)+K02(3)]D2+[g1K21(3)+K01(3)]D1+g1D0  [10h]

K14(4)=g1K24(3)+K04(3),  [10i]

K13(4)=g1K23(3)+K03(3),  [10j]

K12(4)=g1K22(3)+K02(3),  [10k]

K11(4)=g1K21(3)+K01(3),  [10l]

K10(4)=g1  [10m]

P2(4)=g2f4+p1(3)=[g2K24(3)+K14(3)]D4+[g2K23(3)+K13(3)]D3+[g2K22(3)+K12(3)]D2+[g2K21(3)+K11(3)]D1+g2D0  [10n]

K24(4)=g2K24(3)+K14(3),  [10o]

K23(4)=g2K23(3)+K13(3),  [10p]

K22(4)=g2K22(3)+K12(3),  [10q]

K21(4)=g2K21(3)+K11(3),  [10r]

K20(4)=g2  [10s]

From the example calculation and induction, a generalized form for canonical coefficients may be represented by 11a. Relation 11a may represent cases with j>0.

Kj,k−1−i(m)=gjKj,k−1−i(m−1)+Kj−1,k−1−i(m−1)  [11a]

In cases with j=0, relation 11b may be employed.

Kj,k−1−i(m)=gjKj,k−1−i(m−1)  [11b]

Thus, for embodiment 700, for example, previously discussed, values for canonical coefficients using 11a and/or 11b may be calculated.

FIG. 8 is a schematic diagram illustrating an embodiment of an apparatus in the form of a computing system 800 including a memory device in the form of a memory module 810 (wherein the memory device itself could be considered an apparatus), for example. A computing device may comprise one or more processors, for example, to execute an application and/or other code. A computing device 804 may be representative of any device, appliance, and/or machine that may be used to operatively access memory module 810. Memory module 810 may include a memory controller 815 and a memory 822. By way of example, but not limitation, computing device 804 may include: one or more computing devices or platforms, such as, e.g., a tablet computer, a desktop computer, a laptop computer, a workstation, a server device, and/or the like; one or more personal computing and/or communication devices and/or appliances, such as, e.g., a personal digital assistant, mobile communication device, and/or the like; a computing system, such as, e.g., a database, and/or other system; and/or any combination thereof.
It is recognized that all and/or part of the various devices shown in system 800, and/or methods, such as those as further described herein, may be implemented using and/or otherwise including at least one of hardware, firmware, and/or software, other than software by itself. Thus, by way of example, but not limitation, computing device 804 may include one or more processing units 820 operatively coupled to memory 822, such as through a bus 840 and memory controller 815. Processing unit 820 is representative of one or more devices capable of performing a portion of a computing procedure or process. By way of example, but not limitation, processing unit 820 may include one or more processors, microprocessors, controllers, application specific integrated circuits, digital signal processors, programmable logic devices, field programmable gate arrays, the like, and/or any combination thereof. Processing unit 820 may include an operating system to be executed that is capable of communication with memory controller 815. An operating system may, for example, generate commands to be sent to memory controller 815 over and/or via bus 840. Commands may comprise read and/or write commands, for example. In response to a write command, for example, memory controller 815 may perform process 800 described above, to program memory and/or to compute parity data.
Memory 822 may include, for example, a primary memory 824 and/or a secondary memory 826. Primary memory 824 may include, for example, a random access memory, read only memory, etc. While memory may be illustrated as being separate from another device, such as processing unit 820, it should be understood that all and/or part of memory, such as primary memory 824, for example may be provided within and/or otherwise coupled with processing unit 820. In one implementation, memory 822 may be incorporated in an integrated circuit, for example, which may comprise a port to receive error syndromes and/or other ECC data from processing unit 820.
Secondary memory 826 may include, for example, the same and/or similar type of memory as primary memory and/or one or more other types of memories, such as a disk drive, an optical disc drive, a tape drive, a solid state memory drive, etc. In certain implementations, secondary memory 826 may, for example, comprise a storage medium that may include a computer-readable or may be operatively receptive of, and/or otherwise capable of being operatively coupled to an external memory, such as an external computer-readable medium, such as 828. Computer-readable medium 828 may include, for example, any medium that is able to store, carry, and/or make accessible readable, writable, and/or rewritable code, instructions, or any other information for one or more of the devices in system 800. Computing device 804 may include, for example, an input/output device, such as unit 832.
In the preceding description, various aspects of claimed subject matter have been described. For purposes of explanation, specific numbers, systems, and/or configurations may have been set forth to provide a thorough understanding of claimed subject matter. However, it should be apparent to one skilled in the art having the benefit of this disclosure that claimed subject matter may be practiced without those specific details. In other instances, features that would be understood by one of ordinary skill were omitted and/or simplified so as not to obscure claimed subject matter. While certain features have been illustrated and/or described herein, many modifications, substitutions, changes, and/or equivalents may now occur to those skilled in the art. It is, therefore, to be understood that the appended claims are intended to cover all such modifications and/or changes as fall within the purview of claimed subject matter.

## Claims

1. An electronically-implemented method of protecting program data, the method comprising:
retrieving coefficient data for computation of an error protection code using a canonical form, the computed coefficient data representing coefficients employed to compute parity data from program data, wherein the coefficient data is independent of program data;
combining the coefficient data and the program data to compute an error protection code comprising parity data, wherein the parity data comprises a sum of products, wherein the products comprise the coefficient data multiplied by the program data; and
storing the program data and the error protection code in memory.

2. The method of claim 1, wherein storing the coefficient data for the error protection code in memory comprises storing in a memory device of a computing system.

3. The method of claim 1, further comprising computing or retrieving the coefficient data responsive to a selection of the error protection code.

4. The method of claim 3, wherein computing or retrieving responsive to the selection of the error protection code comprises computing responsive to the selection of the error protection code by a user.

5. The method of claim 1, further comprising using the stored program data and the stored parity data to correct one or more errors in the stored program data.

6. The method of claim 1, further comprising computing the parity data in parallel.

7. The method of claim 1, further comprising using the computed coefficient data to compute respective parity data for different sets of program data stored in different memory arrays.

8. The method of claim 1, wherein the computed coefficient data is stored in a look-up table.

9. The method of claim 1, wherein the error protection code comprises a generalized block oriented algebraic error protection code.

10. The method of claim 9, wherein the generalized block oriented algebraic error protection code comprises a BCH code or a Reed-Solomon code.

11. The method of claim 1, wherein the canonical coefficients are based, at least in part, on a generator polynomial.

12. An apparatus comprising:
circuitry configured to compute parity data based, at least in part, on program data and on pre-computed coefficient data representing canonical coefficients for an error protection code, wherein the pre-computed coefficient data are determined independent of the program data, wherein the parity data comprises a sum of products, wherein the products comprise the coefficient data multiplied by the program data; and
a memory array configured to store the parity and program data.

13. The apparatus of claim 12, wherein the circuitry comprises circuitry configured to compute the parity data in parallel.

14. The apparatus of claim 12, wherein the circuitry includes an encoder.

15. The apparatus of claim 12, wherein the circuitry includes a decoder.

16. The apparatus of claim 12, wherein the pre-computed coefficient data is stored in a look-up table included in the circuitry.

17. The apparatus of claim 16, wherein the pre-computed coefficient data comprises coefficient data computed external to the apparatus.

18. The apparatus of claim 12, wherein the circuitry comprises combinational logic circuitry.

19. The apparatus of claim 12, wherein the error protection code comprises a selectable error protection code.

20. The apparatus of claim 19, wherein the selectable error protection code comprises one of the following types: a BCH code or a Reed-Solomon code.

21. The apparatus of claim 12, wherein the apparatus comprises at least one of the following: a memory device, a tablet computer, a desktop computer, a laptop computer, a workstation, a server device, a personal digital assistant, a mobile communication device, or any combination thereof.

22. An apparatus comprising:
parity computing circuit blocks configured to compute associated parity data for corresponding groups of program data, the circuit blocks configured to apply pre-computed coefficients to one or more groups of program data, wherein the pre-computed coefficients are determined independent of the program data, wherein the parity data comprises a sum of products, wherein the products comprise the coefficient data multiplied by the program data; and
a memory array configured to store the parity and program data.

23. The apparatus of claim 22, wherein the pre-computed coefficients are independent of the groups of program data.

24. The apparatus of claim 23, wherein the parity computing circuit blocks are configured to operate in parallel.