Abstract:
Data storage devices using a two-level ECC scheme are described. Embodiments of the invention allow the recovery of sectors in a squeezed group of tracks in a that includes both a single track level ECC scheme and a track band ECC scheme that functions across the set of tracks in the band. The track band ECC scheme uses additional parity information calculated using input data from multiple tracks to allow correction across tracks.

Description:
RELATED APPLICATIONS 
     The subject matter of the present invention is related to the subject matter of co-pending application “SCALABLE REPAIR BLOCK ERROR CORRECTION FOR SEQUENTIAL MULTIPLE DATA BLOCKS IN A MAGNETIC DATA STORAGE DEVICE” bearing Ser. No. 13/645,309 with a filing date of 4 Oct. 2012, which is hereby incorporated by reference. 
     FIELD OF THE INVENTION 
     Embodiments of the invention relate to error correction techniques in magnetic data storage devices. 
     BACKGROUND 
     Conventional disk drives with magnetic media organize data in concentric tracks that are spaced apart. The concept of shingled writing is a form of magnetic recording and has been proposed as a way of increasing the areal density of magnetic recording. In shingle-written magnetic recording (SMR) media a region (band) of adjacent tracks are written so as to overlap one or more previously written tracks. The shingled tracks must be written in sequence unlike conventionally separated tracks, which can be written in any order. Tracks on an SMR disk surface are organized into a plurality of shingled regions. Once written in the shingled structure, an individual track or sector cannot be updated in place, because that would overwrite and destroy the overlapping tracks. 
     ECC in disk drives is used to correct errors and erasures, which occur when a data element is missing or known to be faulty. Traditionally ECC is performed on a sector basis using redundant bits appended to the sector data when it is written. These sector ECC approaches are not ideal for some disk drive applications such as streaming audio-video (AV) and the SMR architecture presents additional ECC problems. A problem addressed by the invention described herein is the recovery of sectors in “squeezed” tracks in a Shingled Magnetic Recording (SMR)-System. 
     US patent application 20110075292 by Richard New, et al. (Mar. 31, 2011) describes SMR drives in which band establishes a respective segment in a log-structured file system. Large error correction (ECC) block sizes within each segment (band) are implemented by storing the intermediate ECC parity state after each partial write of an ECC block. In this case, the ECC block size spans multiple physical sectors, and because of the larger ECC block size the error correction code is more efficient and able to correct larger defect errors on the disk. The ECC code may be implemented in a number of different ways which are known to those skilled in the art of designing ECC codes. 
     U.S. Pat. No. 7,490,212 to Kasiraj, et al. (Feb. 10, 2009) describes ECC for an SMR drive that is useful for recording and playback of video data in transaction data blocks larger than the conventional 512 byte block size but smaller than the band size. Large physical sectors can be used to improve format efficiency, and large ECC codeword sizes (larger than the transaction block size) can be used to improve reliability without imposing a read-modify-write performance on the system. To do this, the disk drive saves the cumulative ECC parity state between successive partial writes of each transaction block so that the parity computed in a first write operation is used to generate the parity for a subsequent write operation. For example, a transaction block size might be one megabyte, and the ECC might span the entire band. Each time a transaction block is written, gradually filling up the band, the cumulative parity state for the ECC is maintained, so that at the end of the last transaction block in that band, the ECC parity can be written out. This provides a very long ECC block size and therefore a very efficient ECC code which is resilient to defects and errors. The ECC code could be very simple, such as a single parity sector computed by XORing all of the data in the physical sectors in the band. This provides protection against a single sector failure within the band. However, using XORing the error correction block is a parity sector that can only correct one data block and is not scalable. 
     Published patent application 20110096828 (Apr. 28, 2011) by Ying Chen, et al. describes a system with encoding and decoding blocks with multiple independent scalability layers. The Forward Error Correction (FEC) is assumed to be applied to a “block” or “fragment” of data at a time, i.e., a “block” is a “source block” for FEC encoding and decoding purposes. A client device can use the segment indexing described herein to help to determine the source block structure of a segment. The FEC codes considered for use with block-request streaming are typically systematic FEC codes, i.e., the source symbols of the source block may be included as part of the encoding of the source block and thus the source symbols are transmitted. A systematic FEC encoder generates, from a source block of source symbols, some number of repair symbols and the combination of at least some of the source and repair symbols are the encoded symbols that are sent over the channel representing the source block. Some FEC codes may be useful for efficiently generating as many repair symbols as needed, such as “information additive codes” or “fountain codes” and examples of these codes include “chain reaction codes” and “multi-stage chain reaction codes”. Other FEC codes such, as Reed-Solomon codes may practically only generate a limited number of repair symbols for each source block. 
     Hard disk drive (HDD) archival applications such as so called “cold-storage” refer to data that is stored for various reasons but is rarely ever read again. For these applications the HDD design tradeoffs between density of storage, access speed, etc. are different than for HDDs used for data that is frequently read. Shingled Magnetic Recording (SMR) designs are particularly suitable and cost effective for cold storage. HDD archival applications such as “Cold-Storage” require increased capacities, obtained by TPI-Increase, as well as Data Integrity that guarantees data retrieval. These are conflicting requirements, as TPI increases by squeezing the width of the tracks, invariably results in unreadable “squeezed sectors”. 
     SUMMARY OF THE INVENTION 
     Embodiments of the invention described herein allow the recovery of sectors in a squeezed group of tracks using a two-level ECC scheme that includes both a single track level ECC scheme and a track band ECC scheme that functions across the set of tracks in the band. The track band ECC scheme uses additional parity information calculated using input data from multiple tracks to allow correction across tracks. 
     In embodiments of the invention tracks are organized into groups or bands of tracks (which will be called ECC track bands) that allow squeezed-sector corrections across tracks. In addition to the first level ECC capability for error corrections in a single track, embodiments of the invention use an ECC track band with reserved space for redundant parity sectors to dynamically correct for errors in a written track that exceed the first level ECC for the track. In some embodiments the additional parity information is written within the ECC track band, e.g. in the last track of the band. In alternative embodiments the track band parity sectors can be written in an exception track, which is not adjacent to the other tracks in the band, that is dedicated to track band parity sectors. In Shingled Magnetic Recording (SMR) disk drives, sequential logical blocks of user data are generally written in sequential physical tracks in shingled regions, so an ECC parity block that covers multiple sequential tracks according to the invention is practical without incurring a large performance penalty. 
     Embodiments of the invention are particularly useful in cold-storage applications by a) helping to achieve specified hard-error rate data recoverability in cold-storage devices, and b) increasing the sector erasure correction capability in the presence of “aging” and adjacent track interference (ATI) and far track interference (FTI) which can cause track squeeze propagation. In an exemplary embodiment of the invention data capacity can be increased by 25% increasing track squeeze with the extra ECC protection blocks taking up only an additional 1% of capacity, for a net 24% data increase. 
     Although the second level track band ECC according to the invention can be implemented using different mathematical algorithms than are used for first level single track ECC, embodiments will be described in which complementary algorithms are used for each level. An algebraic solution disclosed for particular embodiments of the invention integrates the sector-data in an ECC track band by using a Vandermonde Matrix discrete Fourier transform (DFT) in tandem with a Cauchy-Matrix Parity Sector Encoder to generate Track Band Parity Sectors for a track band. Both matrices are structured matrices, such that encoder/syndrome-generator and decoder are implemented using iteratively calculated programmable-multipliers and SRAM-storage accumulators. 
    
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
         FIG. 1  is a block diagram illustrating a track encoder according to an embodiment of the invention. 
         FIG. 2  is a block diagram illustrating a track band encoder according to an embodiment of the invention. 
         FIG. 3  is a block diagram illustrating a track band decoder according to an embodiment of the invention. 
         FIG. 4  is a block diagram illustrating the flow of the write track band ECC system according to an embodiment of the invention. 
         FIG. 5  is a block diagram illustrating the flow of the read track band ECC system according to an embodiment of the invention. 
         FIG. 6  is a block diagram illustrating the track band layout according to an embodiment of the invention. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Statistical test data on squeeze-errors suggests that within a selected band of adjacent tracks the number of “bursty tracks” in which the number of squeezed sectors exceeds an average number, is relatively small. This empirical evidence suggests that a Squeezed Sector Erasure Correction Scheme, that calculates Track Band Parity Sectors within a selected Band of Tracks to correct a large number of “Squeezed Sectors” read error in a limited number of “Bursty-Tracks” can solve the problem of both guaranteeing required data retrieval reliability, as well as increasing capacity by allowing narrower tracks that result in some squeezed data errors. The empirical data suggests that embodiments of such a scheme according to the invention will permit 20% TPI capacity gain at the expense of less than 2% additional parity sector overhead, which includes both track-parity sectors as well as track-band parity sectors. 
     Embodiments of the invention add Track Band Parity Sectors that can be applied to any “Bursty Track” in which the number of unreadable Squeezed Sectors exceeds the level-1 single Track-ECC correction capability. This approach is better than providing all individual tracks with a maximum number of Parity Sectors, capable of restoring all the Bursty-Track data, which would cause the loss of the TPI-Squeeze capacity gain in increased overhead. 
     The algebraic solution disclosed herein for embodiments of the invention integrates the sector data in a track band by using a Vandermonde Matrix DFT (discrete Fourier transform) in tandem with a Cauchy-Matrix Parity Sector Encoder to generate “Track Band Parity Sectors”. Both matrices are structured matrices, such that the encoder/syndrome-generator and decoder are implemented using iteratively calculated Programmable-Multipliers and SRAM-Storage Accumulators, that are used in SMR hard disk controller (HDC) implementation. Note that standard Reed-Solomon (RS) code shift-register implementation is unacceptable for this application. 
     The implementation of one embodiment of the invention uses programmable Cauchy Matrix generators and SRAM parity sector data storage implemented in hardware in the hard disk controller (HDC). In the first level track ECC, R 1  parity sectors per track are implemented to provide for restoration of R 1  squeezed sectors in each track in an n track band with N sectors per track. In the second level ECC, B×R 2  parity sectors, which are flexibly available to be used in any bursty track within the track band, provide for restoration (R 1 +R 2 ) squeezed sectors in B bursty tracks within the n track band. As an example, with n=64, N=348, B=7, R 1 =6, R 2 =6, with a standard 20% squeeze test data suggests that 2% overhead for the two level scheme provides guaranteed data integrity for a standard Cold Storage application. 
     The implementation of an embodiment of the invention will now be described. The track-level R 1  parity N sector programmable multiplier operates as follows:
 
 P   j,l   (k) =Σ i=1   N   g   i,j   1   m   i,l   k   ,G=[g   i,l   1 ]
         Fix k track index and l symbol index, then sum over i sector index to generate l-th symbol of j-th parity sector for k-th track.   Iteratively calculate (cumulatively store in SRAM):
 
 P   j   (k)   =[P   j,l   k   ]l= 1, . . . , K,k -th track/ j -th parity sector.
   Index Ranges are defined as:
           Track Index kε[1, n]   Parity Sector Index jε[1, . . . , R 1 ]   Sector Index iε[1, . . . , N]   Symbol Index lε[1, K]   
               

     The operation of the 4K sector Cauchy-Matrix encoder embodiment over Galois field GF(2 12 ) is described as follows:
 
 GF *(2 12 )={ z   k   },kε[ 1,2 12 −1], z|z   12   +z   6   +z   4   +z +(1:: GF (2))
 
     
       
         
           
             
               
                 First 
                 ⁢ 
                 
                   - 
                 
                 ⁢ 
                 Level 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   G 
                   1 
                 
               
               = 
               
                 1 
                 
                   
                     a 
                     j 
                   
                   + 
                   
                     b 
                     i 
                   
                 
               
             
             , 
             
               
                 rank 
                 - 
                 
                   ( 
                   
                     G 
                     1 
                   
                   ) 
                 
               
               = 
               
                 R 
                 1 
               
             
           
         
       
       
         
           
             
               
                 a 
                 j 
               
               = 
               
                 z 
                 i 
               
             
             , 
             
               j 
               ∈ 
               
                 
                   [ 
                   
                     1 
                     , 
                     
                       R 
                       1 
                     
                   
                   ] 
                 
                 - 
                 
                   Row 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   Index 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               b 
               = 
               
                 z 
                 499 
               
             
             , 
             
               i 
               ∈ 
               
                 
                   [ 
                   
                     1 
                     , 
                     N 
                   
                   ] 
                 
                 - 
                 
                   Column 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   Index 
                 
               
             
           
         
       
       
         
           
             
               
                 Second 
                 ⁢ 
                 
                   - 
                 
                 ⁢ 
                 Level 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   G 
                   2 
                 
               
               = 
               
                 1 
                 
                   
                     a 
                     j 
                   
                   + 
                   
                     b 
                     i 
                   
                 
               
             
             , 
             
               
                 rank 
                 - 
                 
                   ( 
                   
                     G 
                     2 
                   
                   ) 
                 
               
               = 
               
                 
                   R 
                   2 
                 
                 - 
                 
                   R 
                   1 
                 
               
             
           
         
       
       
         
           
             
               
                 a 
                 j 
               
               = 
               
                 z 
                 i 
               
             
             , 
             
               j 
               ∈ 
               
                 
                   [ 
                   
                     
                       
                         R 
                         1 
                       
                       + 
                       1 
                     
                     , 
                     
                       R 
                       2 
                     
                   
                   ] 
                 
                 - 
                 
                   Row 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   Index 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               b 
               = 
               
                 z 
                 499 
               
             
             , 
             
               j 
               ∈ 
               
                 
                   [ 
                   
                     1 
                     , 
                     N 
                   
                   ] 
                 
                 - 
                 
                   Column 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   Index 
                 
               
             
           
         
       
     
       FIG. 1  is a block diagram illustrating a first level track encoder according to an embodiment of the invention as described above. 
     An n-track band parity sector generator embodiment is described as follows:
         Track-Band Level R 2  Parity Encoder for B tracks with more than R 1  and up to R 1 +R 2  erased sectors:
           B×n-Vandermonde Matrix V=[Z k     b   ], kε[0, . . . , n−1], bε[0, . . . , B−1] entries are used as cross-track DFT multipliers to create invertible B distinct n track combinations, each encoded into R 2  parity sectors.   Any B×B submatrix of the B×n-Vandermonde Matrix, defined by B bursty track column pointers, is iteratively invertible. (This is implemented as Media Error Detection Code (MEDC) Erasure Decoder, see related application bearing Ser. No. 13/645,309); Thus, in any 8 bursty tracks within the n track band, up to R 1 +R 2  squeezed (erased) sectors can be recovered and restored.   
               

     The B×R 2 -Track Band Parity Sector Generator is further described as follows:
         R 2 -Track Band Parity Sectors are calculated for B-DFT sums of the n-Track Band
 
 {circumflex over (P)}   j,l   (b) =Σ k=0   n-1   z   k     b   Σ i=1   N   g   i,j   (2)   m   i,l   (k)   ,G   2   =[g   i,j   (2) ]
   Programmable-Multiplier Cauchy Matrix
           Fix Bursty-Track Index-b ε[0, . . . , 8−1] and then Sum over Track Index kε[0, . . . , n−1] and Sector Index iε[1, . . . , N] to produce B×R 2  Track Band Parity Sectors.
 
 {circumflex over (P)}   j   (b)   =[{circumflex over (P)}   j,l   (b)   ]l= 1, . . . , K] 
   Parity Sector Index jε[R 1 +1, . . . , R 2 ]   
               

       FIG. 2  is a block diagram illustrating a second level track band encoder according to an embodiment of the invention as described above. 
     The format for writing an n-track band according to an embodiment of the invention is described as follows:
 
 N -sector  T   k   =[M   1   (k)   , . . . ,M   N   (k) ],Index-kTrack,
 
     where T k  is the N-Sector k-th track data.
         Written track includes the user data plus appended parity sectors for the first level ECC:
 
[ T   k   ,P   1   (k)   , . . . ,P   R     1     (k)   ],k= 1, . . . , n  
   where there are R 1  parity sectors P j   (k) ,
 
 jε[ 1, . . . , R   1 ].
   The track band includes additional parity sectors (B×R 2 -Track Band Parity Sectors) for the second level ECC that are written, for example, in either the last track of the band or in an exception track that is dedicated to Track Band Parity Sectors:
 
[ {circumflex over (P)}   j   (b)   ],bε[ 0, . . .  B− 1], j∃[R   1 +1, . . . , R   2 ],
       

     The squeezed-sector modified parity sector encoder for tracks and track bands is further described as follows. The modified parity sector encoder is used in the decoding process. When the sectors on tracks are read back, some of those sectors can be unreadable because track squeeze has in effect erased the magnetic information needed to directly read the data. The MEDC erasure pointers detect squeezed sectors in each track as previously described. The process of recovering the data using the redundant parity includes re-encoding the sectors of data that can be read and skipping sectors that have been erased. The result of this re-encoding process will be called “Modified Parity Sectors” that contain only the contribution of the readable (non-squeezed) sectors. 
     Once this calculation is completed, the “Modified Parity Sectors” are XOR&#39;ed with the original “Written Parity Sectors” to obtain SYNDROMES. These now contain the contribution of only those sectors that were unreadable, and are processed by the Decoder to regenerate the erased data.
 
 {tilde over (P)}   j,l   (k) =Σ′ i   g   i,j   (1)   {tilde over (m)}   i,l   (k)   ,{tilde over (P)}   j   (k)   =[{tilde over (P)}   j,l   (k) ] l=1   K  
         where sum Σ′ i  skips unreadable squeezed sectors to produce track-level modified parity sectors: {{tilde over (P)} j   k } j=1   R     1           

     
       
         
           
             
               
                 P 
                 
                   ~ 
                   ^ 
                 
               
               
                 j 
                 , 
                 l 
               
               
                 ( 
                 b 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 k 
               
               ⁢ 
               
                 
                   z 
                   
                     k 
                     b 
                   
                 
                 ⁢ 
                 
                   
                     ∑ 
                     i 
                     ′ 
                   
                   ⁢ 
                   
                     
                       g 
                       
                         i 
                         , 
                         j 
                       
                       
                         ( 
                         2 
                         ) 
                       
                     
                     ⁢ 
                     
                       
                         m 
                         ~ 
                       
                       
                         i 
                         , 
                         l 
                       
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
               
             
           
         
       
         
         
           
             where Σ k  sums over all tracks and Σ′ i  skips squeezed sectors in each track to cumulatively generate B×R 2 -Modified Track Band Parity Sectors: 
           
         
       
    
     
       
         
           
             
               
                 
                   
                     
                       
                         P 
                         
                           ~ 
                           ^ 
                         
                       
                       j 
                       
                         ( 
                         b 
                         ) 
                       
                     
                     = 
                     
                       
                         [ 
                         
                           
                             P 
                             
                               ~ 
                               ^ 
                             
                           
                           
                             j 
                             , 
                             l 
                           
                           
                             ( 
                             b 
                             ) 
                           
                         
                         ] 
                       
                       
                         
                           l 
                           = 
                           1 
                         
                         , 
                         
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           K 
                         
                       
                     
                   
                   , 
                 
               
             
             
               
                 
                   
                     b 
                     ∈ 
                     
                       [ 
                       
                         0 
                         , 
                         
                           
                             … 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             B 
                           
                           - 
                           1 
                         
                       
                       ] 
                     
                   
                   , 
                 
               
             
             
               
                 
                   j 
                   ∈ 
                   
                     
                       [ 
                       
                         
                           
                             R 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                           + 
                           1 
                         
                         , 
                         
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           R2 
                         
                       
                       ] 
                     
                     . 
                   
                 
               
             
           
         
       
     
     Track-Parity syndrome sectors are generated by XOR-ing the modified read-parity sectors with the written-parity sectors:
 
 S   j   (k)   ={tilde over (P)}   j   (k)   ⊕P   j   (k)   ,jε[ 1, . . . , R   1 ]
 
The track-parity syndrome sectors are the squeezed sectors encoded by the Cauchy submatrix, defined by the squeezed sector pointers in each track, which are recoverable by iterative Cauchy submatrix Inversion.
 
     A track-level syndrome-sector decoder is described in the related application bearing Ser. No. 13/645,309. Restoration of index-k tracks with E 1   (k) ≦R 1  squeezed sectors indexed by MEDC-erasure pointers
 
 T   E,k   =[i   1   (k)   , . . . ,i   E     1     (k) ]
 
Syndrome-sector multiplication by an E 1,k ×E 1,k  Cauchy submatrix, iteratively calculated, inverse restores the E 1,k  squeezed sectors:
 
[ S   j   (k)   ]→[g   i     m       (k)     ,j   (1) ] −1   [S   1   (k)   , . . . S   E     1,k     (k) ] T   →[M   i     m     (k)   ],i   m   (k)   ε[i   1   (k)   , . . . ,i   E     1     (k)   ],j ε[1, . . . , E   1   (k) ]
 
The result is {M i     m     (k) } restored sectors in k-th track. The track level error correction system, therefore, supplies the readable and first level corrected sectors to the track band error correction system for the second-level error correction.
 
     The track-band parity syndrome sector generation process is further as follows. The track-band modified parity sectors are updated: 
     
       
         
           
             
               Δ 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   P 
                   
                     ~ 
                     ^ 
                   
                 
                 
                   j 
                   , 
                   l 
                 
                 
                   ( 
                   b 
                   ) 
                 
               
             
             = 
             
               
                 ∑ 
                 k 
                 ′ 
               
               ⁢ 
               
                 
                   z 
                   
                     k 
                     b 
                   
                 
                 ⁢ 
                 
                   
                     ∑ 
                     
                       i 
                       r 
                     
                     ″ 
                   
                   ⁢ 
                   
                     
                       g 
                       
                         
                           i 
                           r 
                         
                         , 
                         j 
                       
                       
                         ( 
                         2 
                         ) 
                       
                     
                     ⁢ 
                     
                       m 
                       
                         
                           i 
                           r 
                         
                         , 
                         l 
                       
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
               
             
           
         
       
     
     where Sum Σ′ k  skips bursty tracks and
         Sum} Σ″ i     r    is over the Restored Sectors in each non-bursty track.       

     Track-band modified parity sectors after track-level correction update process: 
     
       
         
           
             
               
                 P 
                 
                   ~ 
                   ^ 
                 
               
               j 
               
                 ( 
                 b 
                 ) 
               
             
             = 
             
               
                 
                   [ 
                   
                     
                       
                         P 
                         
                           ~ 
                           ^ 
                         
                       
                       
                         j 
                         , 
                         l 
                       
                       
                         ( 
                         b 
                         ) 
                       
                     
                     + 
                     
                       Δ 
                       ⁢ 
                       
                         
                           P 
                           
                             ~ 
                             ^ 
                           
                         
                         
                           j 
                           , 
                           l 
                         
                         
                           ( 
                           b 
                           ) 
                         
                       
                     
                   
                   ] 
                 
                 
                   
                     l 
                     = 
                     1 
                   
                   , 
                   … 
                   , 
                   K 
                 
               
               ⁢ 
               
                   
               
               ⁢ 
               where 
             
           
         
       
       
         
           
             
               b 
               ∈ 
               
                 [ 
                 
                   0 
                   , 
                   
                     
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       B 
                     
                     - 
                     1 
                   
                 
                 ] 
               
             
             , 
             
               j 
               ∈ 
               
                 
                   [ 
                   
                     
                       
                         R 
                         1 
                       
                       + 
                       1 
                     
                     , 
                     
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         R 
                         2 
                       
                     
                   
                   ] 
                 
                 . 
               
             
           
         
       
     
     The track-band parity syndrome sectors are a Vandermonde submatrix combination of the “bursty” tracks and the Cauchy submatrices defined by the squeezed sector pointers in each b-Index “bursty” track: 
     
       
         
           
             
               
                 
                   S 
                   ^ 
                 
                 j 
                 
                   ( 
                   b 
                   ) 
                 
               
               = 
               
                 
                   
                     P 
                     
                       ~ 
                       ^ 
                     
                   
                   j 
                   
                     ( 
                     b 
                     ) 
                   
                 
                 ⊕ 
                 
                   
                     P 
                     ^ 
                   
                   j 
                   
                     ( 
                     b 
                     ) 
                   
                 
               
             
             , 
             
               j 
               ∈ 
               
                 
                   [ 
                   
                     
                       
                         R 
                         1 
                       
                       + 
                       1 
                     
                     , 
                     … 
                     ⁢ 
                     
                         
                     
                     , 
                     
                       R 
                       2 
                     
                   
                   ] 
                 
                 . 
               
             
           
         
       
     
     The track-band level syndrome-sector decoding process is further described below and illustrated in  FIG. 3 . The iterative inverse of the Vandermonde submatrix is calculated as previously described:
 
 V   T     B     =[z   k     b     n   ],V   T     B     ⊂V  
 
     indexed by Pointers to E B  bursty tracks with E 2   (b     n     )  squeezed sectors, 
     so that R 1 ≦E 2   (b     n     ) ≦R 1 +R 2    
     and T B =[b 1 ,b 2 , . . . , b E     B   ], E B ≦B. 
     Bursty-track decoupling is performed as:
 
[ Ŝ   j   (b     n     )   ]→V   T     B     −1   [Ŝ   j   (b     n     )   ]→[S   j   (b     n     )   ],jε[R   1 +1, . . . , R   2 ]
 
     Restore E 2   (b     n     ) -Squeezed Sectors in E B  bursty tracks 
     
       
         
           
             
               
                 [ 
                 
                   S 
                   j 
                   
                     ( 
                     
                       b 
                       n 
                     
                     ) 
                   
                 
                 ] 
               
               -&gt; 
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               g 
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   i 
                                   n 
                                   
                                     ( 
                                     
                                       b 
                                       n 
                                     
                                     ) 
                                   
                                 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             
                               g 
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   i 
                                   n 
                                   
                                     ( 
                                     
                                       b 
                                       n 
                                     
                                     ) 
                                   
                                 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                         
                       
                     
                     ] 
                   
                   
                     - 
                     1 
                   
                 
                 ⁡ 
                 
                   [ 
                   
                     S 
                     j 
                     
                       ( 
                       
                         b 
                         n 
                       
                       ) 
                     
                   
                   ] 
                 
               
             
             = 
             
               [ 
               
                 M 
                 
                   i 
                   n 
                 
                 
                   ( 
                   
                     b 
                     n 
                   
                   ) 
                 
               
               ] 
             
           
         
       
       
         
           
             
               
                 i 
                 n 
                 
                   ( 
                   
                     b 
                     n 
                   
                   ) 
                 
               
               ∈ 
               
                 [ 
                 
                   
                     i 
                     1 
                     
                       ( 
                       
                         b 
                         n 
                       
                       ) 
                     
                   
                   , 
                   … 
                   ⁢ 
                   
                       
                   
                   , 
                   
                     i 
                     
                       E 
                       2 
                       
                         ( 
                         
                           b 
                           n 
                         
                         ) 
                       
                     
                     
                       ( 
                       
                         b 
                         n 
                       
                       ) 
                     
                   
                 
                 ] 
               
             
             , 
             
               j 
               ∈ 
               
                 [ 
                 
                   1 
                   , 
                   … 
                   ⁢ 
                   
                       
                   
                   , 
                   
                     E 
                     2 
                     
                       ( 
                       
                         b 
                         n 
                       
                       ) 
                     
                   
                 
                 ] 
               
             
           
         
       
     
       FIG. 4  is a block diagram illustrating the flow of the write process in a track band ECC system according to an embodiment of the invention. The Memory Manager generally functions in the standard way for an SMR disk drive and will have all of the data for a track band stored in memory. The Track Band Encoder, which is programmable in this embodiment, receives as input the “Error-Coverage Parameters” that determine the number of Track Band Parity Sectors required in the particular embodiment. The encoder output is then inserted by the Data Formatter into the data that is fed to the Read/Write Channel, which outputs the data that will be written on the disk. The Data Formatter is also programmable and accepts the Parity Insertion Pointers as an input parameter. The Media Erasure Detection Coder (MEDC) unit MEDC provides the parity data to Data Formatter, which is used to produce Erasure Pointers as needed during the read process. The track band parity sectors are written using the same basic recording techniques as are used for user data sectors in the disk drive; therefore, the Read/Write Channel, arm electronics (not shown), and read/write heads (not shown) handle the parity data bits and sectors like any other data bits and sectors. 
       FIG. 5  is a block diagram illustrating the flow of the read process in a track band ECC system according to an embodiment of the invention. The data read from the disk flows into the Read/Write Channel. The Media Erasure Detection Coder (MEDC) unit MEDC produces Erasure Pointer input to the Track Band Decoder. The Erasure Pointers indicate the sectors that need to be skipped in the syndrome calculation as describe above. The recovered sector output from the Track Band Decoder is provided to the Memory Manager. The recovered sectors are then sent upstream to the requesting component or system such as a host computer.