Abstract:
Apparatus and method for correcting errors in data recovered from a magnetic medium includes detecting the data recovered from the read wave form, and performing an arithmetic operation such as division on the recovered data sequence to determine any non-zero remainder as an indication of an error event. The recovered data sequence is corrected in response to logical determination of a possible event error and position in the recovered data sequence from a collection of predetermined error and position for which the division of the corrected data sequence yields zero remainder.

Description:
FIELD OF THE INVENTION 
     This invention relates to read channel technology for digital data storage systems, and more particularly to a post-processor based upon cyclic code rather than parity code. 
     BACKGROUND OF THE INVENTION 
     Digital data storage systems such as magnetic disks and associated drive apparatus commonly incorporates a so-called read channel that retrieves the accessed data from the analog waveforms provided by the read-head transducer interacting with the magnetic domains on the magnetic disk. As illustrated in FIG. 1 a , this technique involves a magnetic disk and head assembly  100  including a stack of several rigid magnetic disks and several magnetic transducers positioned on a movable arm  105  for operable interaction with the magnetic recording surfaces on each disk. These magnetic heads slide or ‘fly’ in close proximity over the surfaces of the magnetic disks  102  to react to the changes in orientations of magnetic fields of tiny magnetic domains on the disks that represent the stored data. These interactions with magnetic fields produce electrical signals of constantly varying amplitudes that are pre-amplified to produce resulting analog waveforms  106 , as shown in FIG. 1 b , that are applied to a read-channel integrated circuit  108 , as shown in FIG. 1 c . The read channel integrated circuit  108  processes the waveform and produces data-representing signals having digital waveforms  110 , as shown in FIG. 1 d . The same integrated circuit  108  is also used during data-writing processes to transform user data in digital form to analog waveforms that are then recorded on a disk  102  via the associated magnetic transducer. 
     FIGS. 2 and 3 illustrate typical flow of data and signals during read and write operations. During the write operation shown in FIG. 3, the user data is first encoded using a modulation code encoder  300 . The encoded data is then supplied to a waveform generator  302 . During the read process, shown in FIG. 2, the data is first passed through the analog front end  204  and is then supplied to analog-to-digital converter  202 . The digitized signal is then supplied to a digital front end  200  which includes digital equalization and a variety of algorithms facilitating gain and timing tracking. After passing through the digital front end, digital samples are supplied to Viterbi algorithm  206  where the user data is extracted from the input signal. The output of Viterbi algorithm, while mostly correct, typically contains a number of errors, and a post-processor  208  is therefore used to reduce the rate at which the errors occur. Then, the data is supplied to the modulation code decoder  210 . 
     In conventional systems, the post-processor uses parity bits to check for error events. For example, given a word containing 33 bits b 33 ,b 32 , . . . ,b 2,b   1 , bit b 34  is added such that: 
     
       
         b 34 +b 33 +b 32 + . . . +b 2 +b 1 =0  Eqn. (1) 
       
     
     where + stands for “exclusive-or” operation. The codeword b 34 , b 33 , b 32 , . . . , b 2 , b 1 , is then recorded on the media. If, during the read process, Viterbi algorithm makes an error, for example, in 32 nd  bit, producing {overscore (b)} 32  instead of b 32  (here {overscore (0)}=1, {overscore (1)}=0), then the control sum Eqn. (1) becomes equal to 1 instead of 0 which indicates that there is an error somewhere in the block of 34 bits. Post-processor uses this information to correct the error. Post-processor will also detect other error events, such as when three nearby bits are wrong, e.g. Viterbi outputs {overscore (b)} 32 ,{overscore (b)} 31 ,{overscore (b)} 30  instead of b 32 ,b 31 , b 30 . 
     SUMMARY OF THE INVENTION 
     In accordance with the present invention, a post-processor is formed and operated based on a cyclic code rather than on a parity code. The invention can be further understood with the following brief mathematical description of cyclic codes. 
     Every cyclic code is based on a generator polynomial g(x) with binary coefficients: 
     
       
         g(x)=g 0 +g 1 x+g 2 x 2 + . . . +g m x m   Eqn. (2) 
       
     
     When n-m user bits b m ,b m+1 , . . . , b n−2 ,b n−1  are sent to the cyclic code encoder, m extra bits b 0 ,b 1 , . . . ,b m−1  are appended at the end of the codeword. The overall code rate is hence (n−m)/n. During the encode process a division with remainder is preformed as follows. The input data bits can be thought of as a polynomial 
     
       
         b input (x)=b m x m +b m+1 x m+1 + . . . b n−2 x n−2 +b n−1 x n−1   Eqn. (3) 
       
     
     of degree n&#39;11. Dividing the polynomial b input (x) by g(x) yields a remainder r(x): 
     
       
         b input (x)=a(x)g(x)+r(x)  Eqn. (4) 
       
     
     Here the division is performed modulo  2 . Such division with remainder is commonly used in codes and further details can be found in the literature. The remainder r(x) is a polynomial of degree m−1: 
     
       
         r(x)=r 0 +r 1 x+ . . . +r m−1 x m−1   Eqn. (5) 
       
     
     Then, setting: 
     
       
         b j ={overscore (r)} j  for j=0, 1, . . . , m−1  Eqn. (6) 
       
     
     The result of this encoding is that the output data word b 0 ,b 1 , . . . ,b n−1 , viewed as a polynomial 
     
       
         b(x)=b 0 +b 1 x+ . . . +b n−1 x n−1   Eqn. (7) 
       
     
     is divisible by generator polynomial g(x) without remainder. Hence during the error detection process, division is performed with remainder on every n-bit codeword coming out from the Viterbi algorithm and if a remainder is not equal to zero, the post-processor is activated to correct the error. 
     Cyclic codes are the codes which employ a generator polynomial g(x), and which in addition satisfy the requirement that polynomial x n +1 is divisible by g(x) without remainder. If this requirement is satisfied then the resulting code enjoys the so-called cyclic shift property, namely that if b 0 ,b 1 ,b 2 , . . . b n−1  is valid codeword (i.e. corresponding polynomial is divisible by g(x) without remainder) then a cyclically shifted codeword b 1 ,b 2 , . . . , b n−1 ,b 0  is also a valid codeword. 
     The reason why the cyclic property is important is because if an error event (e.g., Viterbi algorithm produces {overscore (b)} 32 ,{overscore (b)} 31 ,{overscore (b)} 30  instead of b 32 ,b 31 ,b 30 ) is detected (i.e. the remainder becomes non-zero as a result of error event) then a shifted error event (e.g. Viterbi outputs {overscore (b)} 7 ,{overscore (b)} 6 ,{overscore (b)} 5  instead of b 7 ,b 6 ,b 5 ) is detected as well, as described below in greater detail. 
     It should also be noted that the cyclic code redundancy bits do not necessarily have to be inserted at the end of the codeword as it was in the mathematical description above. Redundancy bits can be inserted in the middle of the codeword or can even be scattered throughout the codeword and still achieve the property that the resulting codeword polynomial Eqn. (1) is divisible by generator polynomial g(x) and the cyclic property is intact. 
     When the cyclic code post-processor is used, according to the present invention, the read path, for example, as shown in FIG. 2, is modified to incorporate a cyclic code post-processor as shown on FIG. 5 with a cyclic code post-processor substituted for the post processor (parity type)  208  of FIG.  2 . The write path in FIG. 3 is modified to incorporate a cyclic code encoder, as shown in FIG.  6 . Modulation code encoder  600  produces an output that is applied to the cyclic code encoder  602  where the cyclic redundancy bits are calculated and inserted into the codeword. The output of encoder  602  is then supplied to the waveform generator  604 . 
    
    
     DESCRIPTION OF THE DRAWINGS 
     FIGS. 1 a-d  are, respectively, pictorial illustrations of a stack of magnetic data storage disks, operational analog waveforms on a transducer associated with a storage disk, integrated read-channel circuit chip, and digitized waveform of an analog waveform; 
     FIG. 2 is a block schematic diagram of a conventional read path of a channel circuit; 
     FIG. 3 is a block schematic diagram of a conventional write path of the channel circuit; 
     FIG. 4 is a block schematic diagram of the overall architecture of one embodiment of a post processor according to the present invention; 
     FIG. 5 is a block schematic diagram of an embodiment of the overall architecture of a read path of a channel circuit according to the present invention; 
     FIG. 6 is a block schematic diagram of an embodiment of the overall architecture of a write path of a channel circuit according to the present invention; and 
     FIG. 7 is a flow chart illustrating operation of the post processor according to the present invention. 
    
    
     DESCRIPTION OF THE INVENTION 
     With reference to the write path of a channel illustrated in FIG. 6, operation is similar to operations as previously described with reference to the conventional write path of the conventional channel of FIG. 3, with specific distinction in the operation of the cyclic code encoder according to the following description. Incoming data in digital form is first encoded in the modulation code encoder  600  using a modulation code such as, for example, a rate 64/65 Run-Length Limited (RLL) code such as is commonly reported in the literature. The RLL-encoded data is then precoded with a transfer function:              1     1   ⊕     D   2               Eqn   .                (   8   )                                  
     meaning that precoded bits b i  are computed from un-precoded bits u i  according to the equation b i =u i +b i−2  where + represents modulo  2 . 
     The precoded data is then supplied, in blocks of 65 bits, to the cyclic code encoder  602 . The remainder is computed using a generator polynomial 
     
       
         g(x)=1+x+x 2 +x 4   Eqn. (9) 
       
     
     Denoting the input bit by b 4 ,b 5 ,b 6 , . . . ,b 68 , then the mathematical equation for the remainder is given by 
     
       
         b input (x)=a(x)g(x)+r 0 +r 1 x+r 2 x 2 +r 3 x 3   Eqn. (10) 
       
     
     where polynomial b input (x) is given by 
     
       
         b input (x)=b 4 x 4 +b 5 x 5 +b 6 x 6 + . . . +b 68 x 68   Eqn. (11) 
       
     
     and where r 0 ,r 1 ,r 2 ,r 3  are the remainder bits. The encoder then appends redundancy bits 
     
       
         b 0 ={overscore (r)} 0 , b 1 ={overscore (r)} 1 , b 2 ={overscore (r)} 2 , b 3 ={overscore (r)} 3   
       
     
     at the end of the codeword. 
     Efficient implementations of the process of calculating the remainder bits in Equation (10) are described in the literature. 
     It should be noted that the generator polynomial g(x)=1+x+x 2 +x 4  does not divide polynomial x 69 +1 without remainder and hence the resulting 65/69 code is not cyclic. However, by appending an extra bit b 69 , which is always set to zero, to the sequence of data, then the resulting 66/70 code is cyclic because g(x) divides x 70 +1 without remainder. Since adding b 69 x 69 =0 does not change the remainder bits in Equation (10), the bit b 69  does not have to be actually added in hardware and can remain a mathematical abstraction. The 65/69 code is therefore an example of a “shortened cyclic code”, where “shortened” refers to the fact that virtual zero(s) need to be added for the code to enjoy the cyclic shift property, as described above. 
     One way to analyze the performance of Read-Channel integrated circuit chip  108  is by looking at responses to error events. The following mathematical discussion explains the determination of which error events are detected and which are not, thus facilitating design of the post-processor circuit architecture. 
     Consider that codeword b 0 , b 1 , . . . , b 68  was recorded on the media and that codeword b′ 0 , b′ 1 , . . . , b′ 68  was produced by the Viterbi algorithm. The difference between the two, if not equal to all zeros, is commonly referred to as an error event. It is known, for example, that at high user bit density the most common error event is (+1,−1,+1) meaning that:                    b   0   ′     -     b   0       =   0          
              b   1   ′     -     b   1       =   0          
        …        
              b     j   -   1     ′     -     b     j   -   1         =   0          
              b   j   ′     -     b   j       =     +   1            
              b     j   +   1     ′     -     b     j   +   1         =     -   1            
              b     j   +   2     ′     -     b     j   +   2         =     +   1            
              b     j   +   3     ′     -     b     j   +   3         =   0          
        …        
              b   68   ′     -     b   68       =   0             Eqn   .                (   12   )                                  
     for some j. It is easy to see that adding a single parity bit to a codeword will catch error events (+1,−1,+1) and (+1) but will not catch (+1,−1). Hence the performance of the corresponding read-channel circuit, having a read path, for example as shown on FIG. 2, will be dominated by the error event (+1,−1). Similar analysis can be performed for codes containing two, three, etc. parity bits. 
     In order to determine if an error event (+1,−1,+1) is detected in the cyclic code with g(x)=1+x+x 2 +x 4 , note that the remainder of b′(x) is equal to the remainder of b′(x)−b(x). The difference b′(x)−b(x) can be written, modulo  2 , as 
     
       
         b′(x)−b(x)=x j +x j+1 +x j+2   Eqn. (13) 
       
     
     Due to the cyclic shift property, the remainder of Equation (13) is equal to zero if and only if the remainder of its shifted version 
     
       
         v(x)=1+x+x 2   Eqn. (14) 
       
     
     is equal to zero. However the remainder of v(x) when divided by g(x) is equal to v(x) and therefore is not zero. Therefore the error event (+1,−1,+1) is detected by the cyclic code regardless of where it occurs in the codeword. 
     Listed below in Table 1 are 12 most frequent error events occurring in the output of the Viterbi algorithm for low user bit density magnetic recording channel: 
     
       
         
               
               
               
             
           
               
                   
                 TABLE 1 
               
               
                   
                   
               
             
             
               
                   
                 Event 1: 
                 +1 
               
               
                   
                 Event 2: 
                 +1,−1,+1 
               
               
                   
                 Event 3: 
                 +1,−1 
               
               
                   
                 Event 4: 
                 +1,−1,+1,−1,+1 
               
               
                   
                 Event 5: 
                 +1,−1,+1,−1 
               
               
                   
                 Event 6: 
                 +1,0,0,+1 
               
               
                   
                 Event 7: 
                 +1,−1,+1,−1,+1,−1 
               
               
                   
                 Event 8: 
                 +1,0,+1 
               
               
                   
                 Event 9: 
                 +1,−1,+1,−1,+1,−1,+1 
               
               
                   
                 Event 10: 
                 +1,0,+1,0,+1 
               
               
                   
                 Event 11: 
                 +1,−1,+1,0,0,+1 
               
               
                   
                 Event 12: 
                 +1,0,0,+1,−1,+1 
               
               
                   
                   
               
             
          
         
       
     
     It should be noted that every event in the table represents in fact two events: itself and its negative. For example event 2 could be (+1,−1,+1) or it could be (−1,+1,−1). The generator polynomial g(x)=1+x+x 2 +x 4  will catch Events 1 through 11 but will not catch Event 12. Hence for this shortened cyclic code the post-processor should be designed to correct the first 11 events in the table. 
     The overall system architecture incorporating the cyclic code post-processor according to the present invention is shown on FIG. 5, as previously discussed herein, and the architecture of the post-processor  508  is shown on FIG.  4 . Input samples are first applied to the Viterbi algorithm  400 . The output of the Viterbi algorithm is applied to circuitry  402  which performs remainder calculation in accordance with the mathematical Equation (10). 
     If the remainder bits are not all equal to zero, the post-processor will then try to correct the error according to the following strategy. For every bit location j=0, . . . , 68 it uses the remainder and Viterbi output to determine which error events (1 through 11) could have occurred starting from the bit b j . Then it assigns a measure of likelihood, called Maximum Likelihood Distance Penalty (MLDP), to every feasible error event. The post-processor chooses the event with the smallest MLDP among all feasible events for all starting positions. 
     To describe this strategy in further details, reference is made to FIG.  4 . To describe this process, consider an example when j=0, when the Viterbi output bits are: 
     
       
         b 0 =1, b 1 =0, b 2 =0, b 3 =1, b 4 =1, b 5 =0, b 6 =1, b 7 =1,  Eqn. (15) 
       
     
     and the remainder bits are: 
     
       
         r 0 =1, r 1 =0, r 2 =0, r 3 =1  Eqn. (16) 
       
     
     By examining the Non-Return to Zero (NRZ) bits, it is noted that only events number 1,3 and 6 in Table 1 could have occurred starting from bit b 0 . Which of these three error events yield the remainder equal to Equation (16) are the determined. The remainders can be easily computed off line and stored in the following table: 
     
       
         
               
               
               
               
               
               
             
               
               
               
               
               
               
             
           
               
                 TABLE 2 
               
               
                   
               
               
                 Event # 
                 Event 
                 r0 
                 r1 
                 r2 
                 r3 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 1 
                 +1 
                 1 
                 0 
                 0 
                 0 
               
               
                 2 
                 +1,−1,+1 
                 1 
                 1 
                 1 
                 0 
               
               
                 3 
                 +1,−1 
                 1 
                 1 
                 0 
                 0 
               
               
                 4 
                 +1,−1,+1,−1,+1 
                 0 
                 0 
                 0 
                 1 
               
               
                 5 
                 +1,−1,+1,−1 
                 1 
                 1 
                 1 
                 1 
               
               
                 6 
                 +1,0,0,+1 
                 1 
                 0 
                 0 
                 1 
               
               
                 7 
                 +1,−1,+1,−1,+1,−1 
                 0 
                 1 
                 1 
                 0 
               
               
                 8 
                 +1,0,+1 
                 1 
                 0 
                 1 
                 0 
               
               
                 9 
                 +1,−1,+1,−1,+1,−1,+1 
                 1 
                 0 
                 1 
                 1 
               
               
                 10 
                 +1,0,+1,0,+1 
                 0 
                 1 
                 0 
                 0 
               
               
                 11 
                 +1,−1,+1,0,0,+1 
                 1 
                 0 
                 0 
                 1 
               
               
                   
               
             
          
         
       
     
     Among events 1, 3 and 6, only event number 6 will have the remainder bits equal to Equation (16). Hence the MLDP need only be computed for event number 6. 
     The process of determining error event feasibility for j=1, j=2, etc., follows Meggitt decoder, as reported in the literature. For j=1, the updated remainder r (1) (x) is computed, which is equal to remainder after division of xr(x) by g(x): 
     
       
         r (1) (x)=Remainder[xr(x), g(x)]  Eqn. (17) 
       
     
     Then in order to determine which error events beginning at bit b 1  would agree with the remainder information, the same Table 2 can be used, but with r 0   (1) ,r 1   (1) ,r 2   (1) ,r 3   (1)  instead of r 0 ,r 1 ,r 2 ,r 3 . For example, NRZ bits b 1  through b 7  indicate that only event number  1  with reversed sign (i.e. “−1”) could have occurred. In order to determine if this event agrees with the remainder information, compute: 
     
       
         r (i) (x)=Remainder[x+x 4 , g(x)]=1+x 2   Eqn. (18) 
       
     
     The only event with such remainder in Table 2 is number  8  and therefore there are no feasible error events beginning at bit b 1 . 
     Similarly, for position j, the remainder is updated: 
     
       
         r (j) (x)=Remainder[xr (j−1) (x), g(x)]  Eqn. (19) 
       
     
     and Table 2 is used with r 0   (j) ,r 1   (j) ,r 2   (j) ,r 3   (j)  instead of r 0 ,r 1 ,r 2 ,r 3 . 
     Referring now to FIG. 4, the remainder bits computed in circuit  402  are sent to the remainder update circuit  410  where the remainder bits are continuously updated in accordance with Equation (19). At the same time, output from Viterbi algorithm  400 , appropriately delayed  406 , is used in NRZ bit event check  430  to rule out error event which do not agree with the NRZ bits. Table 2 is implemented in the remainder decode circuit  428  where the updated remainder bits from the remainder update circuit  410  are used to rule out error events which are not consistent with the remainder information. 
     The post-processor of FIG. 4 corrects for feasible errors by a process that begins with reconstructing the noiseless samples from Viterbi output that are within the channel  408 , and with subtracting actual input samples appropriately delayed  414 . The resulting error is then supplied to a bank of 11 filters  416  which correlate the output with the 11 events in Table 2. Outputs of some of these filters are then disabled in circuit  418  if the signal coming from the remainder decode circuit  428  indicates that corresponding error events are not feasible. Outputs of some of other filters have their sign reversed. This happens when remainder decode circuit  428  sends information that the feasible error event (e.g. −1,0,0,−1) is sign-reversed from the event (e.g. event number 6 in Table 2) for which there is a filter in the bank  416 . A set of different constants (offsets) is then added to the outputs in circuit  420  and the result is sent to the circuit  426  where the minimum is found and compared with the stored global (i.e. over all positions j) minimum. The outputs of the offset circuit  420  are the aforementioned MLDP for different error events. The new global minimum is then stored in global minimum storage  412  and the location j of the new minimum is stored in location storage  424 . At the same time, storage  422  stores the type of error (number 1 through 11) that gave rise to the new global minimum. After post-processor is done with the current codeword, the location and the type of error are sent to the correction circuit  404  where the data is corrected. 
     The coefficients of filters in the bank of filters  416 , and the values of additive constants in the offset circuit  420  are determined according to the following considerations. In many existing magnetic recording systems the equalized channel response has memory of four: 
     
       
         h(D)=h 0 +h 1 D +h 2 D 2 +h 3 D 3 +h 4 D 4   Eqn. (20) 
       
     
     Denote the noisy received samples at the output of delay  414  by r j . Then the input to the bank of filters  416  is given by equation:                s   i     =         ∑     k   =   0       k   =   4              b     i   -   k            h   k         -     r   i               Eqn   .                (   21   )                                  
     The summation:                ∑   i            (     s   i     )     2             Eqn   .                (   22   )                                  
     is called Maximum Likelihood Distance (MLD) and it is precisely the quantity that Viterbi algorithm  400  minimizes by recursing through different possible data sequences b. However Viterbi algorithm  400  has no knowledge of the cyclic code and therefore chooses the sequence b=(b 0 , b 1 , . . . , b 68 , with the smallest sum by Equation (22) without assuring that it is a valid cyclic codeword. Trying to correct for a cyclic code error can only increase the summation by Equation (22) and the amount of increase is referred to as Maximum Likelihood Distance Penalty (MLDP). To facilitate Maximum Likelihood detection of the cyclicly encoded data, the post-processor must find the error event which will correct the remainder and which will have the smallest MLDP. For error event e=(0, . . . , 0, e j , e j+1 , e j+2 , e j+3 , e j+4 , e j+5 , e j+6 , 0, . . . , 0) with starting location j, the MLDP can be computed as follows:                    ∑   i            (       s   i     -       ∑   k            e     i   -   k            h   k           )     2       -       ∑   i          s   i   2         =         ∑   i            (       ∑   k            e     i   -   k            h   k         )     2       -     2          ∑   i            s   i          (       ∑   k            e     i   -   k            h   k         )                     Eqn   .                (   23   )                                  
     The first term in the right hand side of Equation 23 is the offset added in offset circuit  420 . The offset does not depend on sequence s j  but only on the type of error event. For example, for event number 6 in Table 2, the offset is equal to:                  ∑   i            (       ∑   k            e     i   -   k            h   k         )     2       =         (     h   0     )     2     +       (     h   1     )     2     +       (     h   2     )     2     +       (       h   3     +     h   0       )     2     +       (       h   4     +     h   1       )     2     +       (     h   2     )     2     +       (     h   3     )     2     +       (     h   4     )     2               Eqn   .                (   24   )                                  
     The offsets for other error events can be computed in a similar way. The second term in Equation (23) represents the result of filtering of input si coming into the bank of filters  416  in FIG.  4 . For example, the filter for error event number 6 in Table 2 has eight taps equal to: 
      −2h 4  −2h 3  −2h 2  −2(h 4 +h 1 ) −2(h 3 +h 0 ) −2h 2  −2h 1  −2h 0   
     The filter taps for other error events can be computed in a similar manner. 
     After corrections are made in correction circuit  404  of FIG. 4, the data thus produced by the post-processor is supplied to the precode and modulation code decoder  510  of FIG.  5 . The bits are first applied to the precode decoder which has the transfer function 1⊕D 2  and then to the 64/65 RLL code decoder in the circuit  510 . 
     The flowchart illustrating the method of the present invention is shown on FIG.  7 . The data is presumed to have been encoded with a cyclic code prior to being written on a media. Samples of the recorded waveform are retrieved  700 . These samples are used to recover the binary data  702  using the primary detection method. For example, the Viterbi algorithm may be used as such primary detection method. The primary method produces a sequence of data which is mostly correct and where only occasional data correction is needed to further reduce the bit error rate. A remainder r(x) after division by the generator polynomial g(x) is computed  704  for a cyclic code codeword recovered using a method of long division. The remainder is checked  706  for equal to zero. Here polynomial r(x) is said to be equal to zero if all its coefficients r 0 ,r 1 , . . . ,r m  are equal to zero. If the remainder is not equal to zero, then the cyclic codeword is not valid and corrections must be made. So if the response to the inquiry  706  is No, then the process proceeds to find feasible error events and positions  708 . If the answer is Yes, then the process advances to the next codeword, since the current codeword does not require corrections. In finding feasible errors and positions (or, locations)  708 , a determination is made of which error events (from a predetermined collection of dominant error events) and at what locations in the codeword, consistent with the remainder r(x) and with the recovered data sequence. The latter is needed since many dominant error events occur when locations of several consecutive transitions in the recorded waveform are determined incorrectly and hence if the recovered data sequence indicates no transitions, this would not be possible. After all feasible error events (from a predetermined collection of dominant error events) and positions are found, samples of the recorded waveform are used to choose the most likely error event(s) and location(s) among error event(s) and location(s) which were found feasible in step  708 . Note that more than a single error event may be corrected in a codeword. Then, correction  712  for the chosen error event(s) is performed. Finally, the process advances  714  to the next codeword and the whole process repeats starting from step  702 . 
     It should be noted that a parity code, when a parity bit is added to a codeword, can be viewed as a cyclic code with generator polynomial g(x)=x+1. Similarly, a double-parity code when two parity bits are appended to assure that the sum of odd-numbered bits is even and the sum of even-numbered bits is even can be viewed as a cyclic code with generator polynomial g(x)=x 2 +1. However the process of summing up bits to determine the values of parities is different from the recursive process of long division according to the present invention. 
     Another distinct feature of this invention is that step  708  (to determine which events/positions are feasible) is executed prior to executing step  710  (use samples to choose most likely events/positions). This facilitates use of more efficient circuitry than may be used to implement conventional processes. Thus, a cyclic code post processor  508  in the read channel of FIG. 5, and a cyclic code encoder  602  in the write channel provide improved operation over conventional read and write channels resulting from the calculation and insertion (or retrieval) of codewords according to the present invention