Abstract:
Non-uniform modulation encoding techniques are provided to prevent data from containing bit patterns that are prone to errors during read back. Modulation encoding is performed on a data stream to remove error prone bit patterns. Unconstrained data, such as error check parity, that is inserted into the modulated data stream may contain error prone bit patterns. Stricter modulation constraints are enforced on bits that are next to the unconstrained data, than on the remaining bits. By enforcing stricter modulation constraints on these bits, an entire data bit stream can have a desired modulation constraint.

Description:
BACKGROUND OF THE INVENTION 
   The present invention relates to techniques for implementing non-uniform constraints in modulation encoded data, and more particularly, to techniques for providing stronger constraints for modulation encoded data located next to unconstrained information. 
   A disk drive can write data bits onto a data storage disk such as a magnetic hard disk. The disk drive can also read data bits that have been stored on a data disk. Certain sequences of data bits are difficult to write onto a disk and often cause errors during read-back of the data. 
   Long recorded data sequences of the same polarity are examples of data bit patterns that are prone to errors. These data sequences correspond to long sequences of binary zeros or binary ones in the NRZ (non return-to-zero) representation, or alternatively to long sequences of binary zeros in the NRZI or PR4 representations. Another example of error prone data bit patterns are long sequences of zeros in alternating positions (e.g., 0a0b0c0d0 . . . , where a, b, c, d may each be 0 or 1) in the PR4 representation 
   Binary sequences are routinely transformed from one representation to another using precoders and inverse precoders, according to well known techniques. In describing this invention we will represent all binary sequences as PR4 sequences unless otherwise stated. A PR4 representation can be transformed into an NRZI representation by a precoder which convolves with 1/1+D or into an NRZ representation by a precoder which convolves with 1/(1+D 2 ). 
   It is desirable to eliminate error prone bit sequences in user input data. Eliminating error prone bit sequences ensures reliable operation of the detector and timing loops in a disk drive system. One way to eliminate error prone bit sequences is to substitute the error prone bit sequences with non-error prone bit patterns that are stored in memory in lookup tables. Lookup tables, however, are undesirable for performing substitutions of very long bit sequences, because they require a large amount of memory. 
   Many disk drives have a modulation encoder. A modulation encoder uses modulation codes to eliminate sequences of bits that are prone to errors. 
   Maximum transition run (MTR) constrained codes are one specific type of modulation code that are used in conjunction with a 1/(1+D) precoder. With respect to MTR codes, a j constraint refers to the maximum number of consecutive ones in an NRZI representation, a k constraint refers to the maximum number of consecutive zeros in an NRZI representation, and a t constraint refers to the maximum number of consecutive pairs of bits of the same value in an NRZI representation (e.g., aabbccddee . . . ). 
   Codes that constrain the longest run of zero digits in the PR4 representation of a sequence are said to enforce a G-constraint where G is the longest allowed run of consecutive zeros. A G constrained PR4 representation is mapped to a k-constrained NRZI representation by a 1/(1+D) precoder, where k=G+1. 
   Codes that constrain the longest run of zero digits in alternate locations in the PR4 representation of a sequence are said to enforce an I-constraint where I is the longest run of zeros in consecutive odd or even locations. An I-constrained sequence is necessarily G-constrained with G=2I. An I constrained PR4 representation is mapped to a t-constrained NRZI representation by a 1/(1+D) precoder, where t=I. 
   Fibonacci codes are one example of modulation codes that are used by modulation encoders. Fibonacci codes provide an efficient way to impose modulation code constraints on recorded data to eliminate error prone bit sequences. A Fibonacci encoder maps an input number to an equivalent number representation in a Fibonacci base. A Fibonacci encoder maps an input vector with K bits to an output vector with N bits. A Fibonacci encoder uses a base with N vectors, which is stored as an N×K binary matrix. Successive application of Euclid&#39;s algorithm to the input vector with respect to the stored base gives an encoded vector of length N. 
   Disk drives typically have error correction encoders. A Reed-Solomon (RS) encoder is one type of error correction encoder. An RS encoder generates error correction code (ECC) check bytes while a cyclic code generates cyclic redundancy check (CRC) bits or bytes. The CRC encoder inserts CRC check bits or bytes, while the RS encoder inserts ECC check bytes into the data stream before data is written onto a disk. After data is read from the disk, the ECC check bytes are used to correct errors in the data bytes using well known decoding processes. The CRC check bytes are used to validate the corrected data bytes using well known processes. 
   Modulation encoding can be performed prior to RS encoding or after RS encoding. Performing modulation encoding after RS encoding is referred to as forward concatenation. In forward concatenation, data is initially RS encoded. Then the data, CRC and RS parity are modulation encoded, and the modulation encoded data is written onto a disk. Data is subsequently read from the disk and demodulated. RS decoding is performed after the data is demodulated. 
   Codewords of an efficient modulation code containing a single bit in error are frequently decoded to data sequences containing many bits in errors. This undesirable property of the modulation decoder is called error propagation. Error propagation decreases the effectiveness of the RS code, because a relatively small number of bit errors present when the data is read from the disk may be multiplied by error propagation into many bits in error at the input to the RS decoder. These errors may overwhelm the correcting capability of the RS code. 
   Performing modulation encoding prior to RS encoding is referred to as reverse concatenation. Reverse concatenation solves the problem of error propagation, because the RS decoder corrects any errors in the encoded data before that data is demodulated. In most reverse concatenated systems, the RS parity symbols must still be demodulated before the RS code can be decoded. This means that while the effect of error propagation is reduced it is not entirely eliminated. 
   In some reverse concatenation systems, the RS check bytes are not constrained by modulation encoding in order to keep both overhead and complexity low, and the check bytes are inserted into the data stream after modulation encoding. The benefit of this approach is that the RS parity check symbols are neither encoded nor decoded, and thus error propagation by the modulation decoder is entirely avoided. 
     FIG. 1A  illustrates a reverse concatenation technique of this type. Data is initially encoded by a modulation encoder  101 . Modulation encoder  101  generates data  102  that is modulated according to a predetermined constraint. For example, a global constraint may be that modulated data  102  can have no more than 10 consecutive zeros (G=10). The modulated data is then encoded by an RS encoder  103  to generate RS check bytes  104 . RS check bytes  104  are unconstrained. For example, check bytes  104  may contain more than 10 consecutive zeros. 
   Multiplexer  105  inserts the check bytes into the modulated data stream. The combined data stream  107  is then stored on disk  110 . 
   The disadvantage of this approach is that RS parity check symbols when inserted in the data bytes, may create error prone sequences of bits, such as too many consecutive zeros. The insertion of unconstrained check bytes significantly degrades the overall modulation constraint of a modulated data stream. 
     FIG. 1B  illustrates an example of a worst case scenario for the reverse concatenation technique shown in  FIG. 1A . For example, assume that the modulation data  102  has a constraint of G=10, and the RS check bytes are 10 bits long. Although only a maximum of 10 consecutive zeros are allowed in the modulated data  102 , the combined data stream  107  may violate this constraint with a maximum of 20 consecutive zeros (G=20), as shown in  FIG. 1B . 
   Therefore, it would be desirable to provide techniques for preventing error detection and correction codes from containing error prone bit sequences in reverse concatenation schemes in which the ECC parity data is not encoded. 
   BRIEF SUMMARY OF THE INVENTION 
   The present invention provides techniques for implementing non-uniform constraints on data that is modulation encoded in order to achieve uniform constraints on the overall stream containing encoded and unconstrained data. In some reverse concatenation architectures unconstrained error control code parity is inserted into the data stream after modulation encoding. The present invention prevents these parity bits which are not modulation encoded from degrading the overall modulation constraint of the resulting data stream. 
   Specifically the present invention prevents a situation in which a data stream that consists of both modulation encoded data and unconstrained data contains bit sequences that tend to cause errors during read back, such as too many consecutive zeros. Stricter modulation constraints are enforced on modulation encoded data bits that are next to the unconstrained data bits, relative to the remaining modulation encoded data bits. By enforcing stricter modulation constraints on the bits that are next to the unconstrained bits, an entire stream of data can be confined to a desired modulation constraint. 
   Other objects, features, and advantages of the present invention will become apparent upon consideration of the following detailed description and the accompanying drawings, in which like reference designations represent like features throughout the figures. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
       FIG. 1A  illustrates a prior art reverse concatenation technique. 
       FIG. 1B  illustrates an example of a worst case scenario for the reverse concatenation technique shown in  FIG. 1A . 
       FIG. 2A  illustrates a modulation encoder that imposes non-uniform constraints on data in a reverse concatenation scheme according to an embodiment of the present invention. 
       FIG. 2B  illustrates an example of a codeword with non-uniform modulation constraints according to an embodiment of the present invention. 
       FIG. 3  illustrates another example of non-uniform constraints that are implemented on a codeword according to an embodiment of the present invention. 
       FIG. 4  illustrates some of the elements of a base of 100 vectors that give the non-uniform constraints of  FIG. 3 . 
       FIG. 5  illustrates the 100 vectors of the base of  FIG. 4  in decimal form. 
       FIGS. 6–7  illustrate two additional embodiments of codes that provide non-uniform modulation constraints, according to the present invention. 
   

   DETAILED DESCRIPTION OF THE INVENTION 
     FIG. 2A  illustrates a first embodiment of the present invention. Input data is initially encoded by a non-uniform modulation encoder  201  to generate a stream  202  of modulated data. Non-uniform modulation encoder  201  can be, for example, a Fibonacci encoder or another type of encoder that imposes a limit on at least one type of bit sequence. For example, modulation encoder  201  can impose a limit on the number of consecutive zeros in the modulated data output stream  202 . 
   Non-uniform modulation encoder  201  imposes varying constrains on the data stream  202 . A first constraint (G=X) is imposed on a first predetermined number of codeword locations. A second constraint (G=Y) is imposed on a second predetermined number of codeword locations. The second constraint is more stringent than the first constraint (i.e., Y&lt;X). Modulation encoder  201  can also impose a third constraint, a fourth constraint, a fifth constraint, etc. on the modulated data  202 . 
   The stricter code constraint must be applied over a span of locations, surrounding the location at which the unconstrained data will be inserted, sufficient to ensure that the desired constraints are met after unconstrained data is inserted. 
   For example, if a global constraint G=14 is desired after the insertion of ten unconstrained bits between bits  10  and  11  of the constrained sequence, then a modulation code constraint must be enforced that prohibits runs of more than 4 consecutive zeros starting in any of the following locations {7, 8, 9, 10, 11}. 
   It should be understood the techniques of the present invention apply to any type of modulation codes and any type of modulation constraints. For example, the techniques of the present invention can generate non-uniform global and/or interleaved constraints. The techniques of the present invention can also generate non-uniform constraints for MTR codes including non-uniform j constraints, non-uniform k constraints, and non-uniform t constraints. 
   The modulated data  202  is encoded by an error correction encoder  203  using a well known error correction encoding algorithm, such as Reed-Solomon encoding. ECC encoder  203  generates ECC check bytes  204 . ECC check bytes  204  are generated after modulation encoding (which is performed by block  201 ) and left unconstrained. In the embodiment of  FIG. 2A , the ECC check bytes are not constrained by modulation encoding in order to keep both overhead and complexity low, and the check bytes are inserted into the data stream after modulation encoding. 
   Multiplexer  205  inserts the unconstrained check bytes into the modulated data stream to generate a combined data stream  207 . Multiplexer  205  inserts each unconstrained ECC check byte between the bytes that have the stricter constraint (G=Y), as shown in data stream  207 . Each unconstrained ECC check byte is surrounded on both sides by the data bytes that have the stricter constraint (G=Y). 
   An example of an output data stream  207  is shown in  FIG. 2B  and described to illustrate the above concepts. This example is not intended to limit the scope of the present invention in any way. One of skill in the art will understand that many other embodiments are within the scope of the present invention. 
   Encoder  201  can constrain  5  data bytes so that no more than 10 consecutive zeros are allowed in these 5 bytes (G=X=10). The next 2 data bytes that are received are constrained so that no more than 5 consecutive zeros are allowed in these 2 bytes (G=Y=5). ECC encoder  203  generates 10 bit long ECC check bytes. Multiplexer  205  inserts the check bytes into data stream  202  in between the two data bytes that are more strictly constrained by G=5. In this example, the modulation code constraints are varied from byte-to-byte but remain constant within a byte. In general modulation code constraints vary from bit-to-bit irrespective of byte boundaries. 
   A portion of the resulting data is shown in  FIG. 2B . The ECC bytes contain a maximum of 10 consecutive zeros, because they are unconstrained. The data bytes on either side of the ECC bytes are limited to having a maximum of 5 consecutive zeros (G=5). In the worst case scenario illustrated in  FIG. 2B , the ECC check byte is inserted in between a maximum run of 5 consecutive zeros in the G=5 data bytes. The total number of consecutive zeros in the combined bit stream is 15. Therefore, the combined bit stream output of multiplexer  205  has an overall constraint of G=15. This constraint represents a very significant improvement over the G=20 constraint imposed by the prior art system of  FIG. 1A . 
   As mentioned above, non-uniform modulation encoder  201  can be a Fibonacci encoder. Fibonacci encoding of data bit streams to eliminate long strings of ones (or zeros) is well known to those of skill in the data encoding art. An important feature of the present invention is a Fibonacci encoder that, contrary to the traditional ones available in literature, generates a sequence with a varying value of the run-length of 1 s (or of 0s, simply by flipping the bits). This feature allows for regions of data bytes to be subject to a constraint G=X, while other regions are subject to a more stringent constraint G=Y, where Y&lt;X, as depicted in  FIG. 2A . Sets of the unconstrained data (e.g., an ECC check-byte) will be inserted in the regions where G=Y. 
     FIG. 3  illustrates a specific example of how non-uniform constraints of the present invention can be implemented at different locations in a 100 bit codeword. This example is not intended to limit the scope of the present invention. One of skill in the art will understand that many other embodiments are within the scope of the present invention. 
   Two rows  301  and  302  of a table are shown in  FIG. 3 . Because the two rows each have 103 columns, rows  301  and  302  are broken up into 5 sections to fit onto one drawing sheet. Row  301  enumerates the bits of a 100-bit modulation codeword with a non-uniform G constraint. Three 10-bit long symbols, each corresponding to a RS check-byte, have been inserted into the middle of the codeword. 
   Row  302  indicates the non-uniform run-length of zeros (i.e., G constraint) corresponding to each of the 100 bits of the codeword as given by a modulation encoder of the present invention. The G constraints shown in row  302  are forward looking in the sense that each constraint indicates the maximum number of zeros (or ones) allowed at that bit location going forward (to the right in  FIG. 3 ). For example, starting at bit  1 , there may be at most 11 consecutive zeros. As another example, starting at bit  14 , there may be at most 5 consecutive zeros. Thus, the present invention can apply varying constraints at different bit locations in the middle of a codeword. 
   Bits  8  through  14  have global constraints that vary from 11 to 5 for the following reasons. If six consecutive zeros, starting in bit  14 , are disallowed then it is not possible for any allowed sequence starting in bit  13  to contain seven consecutive zeros, because any such sequence would necessarily contain six consecutive zeros in locations  14  through  19 . Similarly, runs of eight consecutive zeros starting in bit location  12  are disallowed and so on. 
   A rate k/n Fibonacci encoder, corresponding rate n/k decoder and associated code constraints are all completely described by an n-element set of k-bit code base vectors. For example, consider the embodiment of the rate 99/100 Fibonacci code shown in  FIGS. 3–5 . The Fibonacci encoder and decoder attain the non-uniform G constraint of  FIG. 3  and they are explicitly described by the set of base vectors shown in  FIGS. 4 and 5 . This Fibonacci code base includes 100 elements B 1 –B 100 . Each of these 100 elements has 99 binary bits. A few of these elements are shown in  FIG. 4  in binary. All 100 of the Fibonacci code base elements are shown in  FIG. 5  in decimal, wherein B 1 =388×2 90 , B 2 =388×2 89 , B 3 =388×2 88 , etc. 
   Two additional embodiments of codes shown in  FIGS. 6–7  are now described. These codes belong to the class of rate-199/200 (G,I)-constrained codes. These codes achieve very tight G- and I-constraints. 
   The generalized Fibonacci code for the even and odd interleave has length N=100. For the base elements B 1 –B 100  the input/output relationship of the Fibonacci encoder for the even or odd interleave is characterized by u 1 2 99 +u 2 2 98 + . . . +u 100 =v 1 B 1 +v 2 B 2 + . . . +v 100 B 100  where u 1 , u 2 , . . . , u 100  are the bits at the input of the Fibonacci encoder for even or odd interleave and v 1 , V 2 , . . . , v 100  are the bits at the output of the Fibonacci encoder for even or odd interleave. For the description of the  FIGS. 6–7  embodiments, the expression v 1 (B′ 99 2 9 )2 90 +v 2 (B′ 98 2 9 )2 89 + . . . +v 100 (B′ 0 2 9 ) 2 −9  is used to represent the output of the Fibonacci encoder for the even or odd interleave. 
   A rate-199/200 code, referred to as Code A, is shown in  FIG. 6 . Code A is based on a rate-9/10 code constrained by a short block encoder, which is described in detail in commonly assigned, co-pending U.S. patent application Ser. No. 11/048273 which is incorporated by reference herein. 
   Code A was designed using an irregular j-constraint of the Fibonacci codes on each interleave. The bases were chosen such that there are three possible insertion locations for 10-bit RS parity symbols. Code A is obtained by serial concatenation with the rate-9/10 short block constrained code. The resulting Code A is a rate-199/200 (G=20, I=10) code. Code A also supports single parity insertions in each interleave between locations  50  and  49 , and at the boundary without weakening of the G- and I-constraints. 
   Another code, Code B, is shown in  FIG. 7 . Code B is constructed in a similar manner as Code A. It uses a rate-13/14 code constrained by a short block encoder in the even and odd interleave, as described in detail in commonly assigned, co-pending U.S. patent application Ser. No. 11/048273, filed herewith. 
   The generalized Fibonacci code is determined by the bases given in  FIG. 7 . This generalized Fibonacci code has a better j-profile than the one of Code A. The resulting Code B is a rate-199/200 (G=20, I=10) code with three locations for 10-bit RS parity symbol insertion that do not weaken the G- and I-constraints. Owing to the improved j-profile of the generalized Fibonacci code, Code B supports more locations for inner parity insertion than Code A, while maintaining the same (G, I)-constraints. 
   In the embodiments of  FIGS. 6 and 7 , the RS symbols are divided into half bytes of 5-bits. Each half byte is separately inserted into more strongly constrained portions of the codewords. In  FIG. 6 , single bit parity information is inserted into the codeword separately from the half bytes. 
   While the present invention has been described herein with reference to particular embodiments thereof, a latitude of modification, various changes, and substitutions are intended in the present invention. In some instances, features of the invention can be employed without a corresponding use of other features, without departing from the scope of the invention as set forth. Therefore, many modifications may be made to adapt a particular configuration or method disclosed, without departing from the essential scope and spirit of the present invention. It is intended that the invention not be limited to the particular embodiment disclosed, but that the invention will include all embodiments and equivalents falling within the scope of the claims.