# Patent

## Title
Method and system for compensating for adjacent tracks during reading of data

## Abstract

A storage controller includes a device controller and a read data channel. The read data channel includes a decoder for decoding output of a detector, where the detector is for reading data requested from a storage medium by the device controller, and the storage medium has a plurality of tracks of data thereon. When the device controller requests data from a current track of data on the storage device, the detector reads an adjacent track of data, the decoder decodes data from the adjacent track of data, the detector reads data from the current track, and the decoder decodes the data read from the current track, based on the decoded and stored data from the adjacent track of data. A storage system includes a storage medium having a plurality of tracks of data thereon and a storage controller as described above.

## Background
CROSS REFERENCE TO RELATED APPLICATIONS
This is a continuation of, commonly-assigned U.S. patent application Ser. No. 12/882,802, filed Sep. 15, 2010, now U.S. Pat. No. 8,300,339, which claims the benefit of, and was with, commonly-assigned U.S. Provisional Patent Application No. 61/247,924, filed Oct. 1, 2009, commonly-assigned U.S. Provisional Patent Application No. 61/294,424, filed Jan. 12, 2010, and commonly-assigned U.S. Provisional Patent Application No. 61/298,119, filed Jan. 25, 2010, each of which is hereby incorporated by reference herein in its respective entirety.


FIELD OF INVENTION
This invention relates to a method and system for reading data that has been recorded in tracks on a storage medium and is read by a read head that moves relative to the surface of the storage medium. More particularly, this invention relates to compensating, during a read operation, for contributions to the read signal from an adjacent track or tracks.
BACKGROUND
In magnetic recording, as one example of a type of recording in which reading and writing are performed by a head that moves relative to the surface of the storage medium, data may be written in circular tracks on a magnetic disk. To read data on a given track, the read head may be centered on that particular track. However, sometimes the read head may deviate from its ideal path and stray “off-track,” with part of the head over the “main track” (i.e., the track to be read) and part of the head over an adjacent track. In such a case, the read-back signal produced at the read head is a superposition of a signal from the main track and a signal from the adjacent track.
In addition, in order to increase recording density, it has become common to write tracks very close to each other. There is even a technique known as “shingled recording” in which adjacent tracks overlap one another. In such cases, the width of the read head may be greater than the track pitch (i.e., the distance between adjacent tracks) which results in a contribution from one or more adjacent tracks in the read-back signal for the main track of interest.
The contribution from an adjacent track presents similar challenges whether it results from small track pitch, in which case it may be referred to as “inter-track interference” (ITI), or from an off-track condition in which case it may be referred to as “off-track interference” (OTI).
SUMMARY
An embodiment of a method for reading a current track of data from a storage device includes reading an adjacent track of data, decoding data from the adjacent track of data, reading data from the current track, and decoding the data read from the current track, including taking account of based on the decoded data from the adjacent track of data.
An embodiment of a storage controller includes a device controller and a read data channel. The read data channel includes a decoder for decoding output of a detector, where the detector is for reading data requested from a storage medium by the device controller, and the storage medium has a plurality of tracks of data thereon. When the device controller requests data from a current track of data on the storage device, the detector reads an adjacent track of data, the decoder decodes data from the adjacent track of data, the detector reads data from the current track, and the decoder decodes the data read from the current track, based on the decoded data from the adjacent track of data.
An embodiment of a storage system includes a storage medium having a plurality of tracks of data thereon; and a storage controller as described above.



BRIEF DESCRIPTION OF THE DRAWINGS
Further features of the invention, its nature and various advantages, will be apparent upon consideration of the following detailed description, taken in conjunction with the accompanying drawings, in which like reference characters refer to like parts throughout, and in which:
FIG. 1 is a simplified schematic view of four shingled data tracks with a read head;
FIG. 2 is a close-up view of three of the tracks of FIG. 1 with a read head;
FIG. 3 shows how a read head may be positioned to pick up signals from only one adjacent track;
FIG. 4 shows a read head in an off-track position;
FIG. 5 is a view, similar to FIG. 1, showing a multiple-track embodiment;
FIG. 6 is a representation of two-dimensional codewords in an embodiment like that of FIG. 5;
FIG. 7 is a schematic representation of apparatus according to a first embodiment of the invention;
FIG. 8 is a schematic representation of apparatus according to a second embodiment of the invention;
FIG. 9 is a schematic representation of apparatus according to a third embodiment of the invention; and
FIG. 10 is a schematic representation of a storage system according to embodiments of the invention.



DETAILED DESCRIPTION
This invention relates to a method and system for factoring out adjacent-track signals from a data storage read-back signal. The goal is to recover a clear main-track data signal, whether the adjacent track signals result from ITI in a case of shingled recording or other small-track-pitch recording techniques, or from OTI in a case where the read head has gone off-track.
FIG. 1 shows a simplified schematic view of four shingled data tracks 101, 102, 103, 104, with a read-head 105 wider than the track pitch. FIG. 2 shows a close-up view of read head 105 and three of the tracks 101, 102, 103, showing the contributions from each track to the read-back signal.
Specifically, if y2, y1, y0 are the respective noiseless channel read-back signals corresponding to three tracks 101, 102, 103 in the absence of ITI, then the component y of the total read-back signal (including ITI from tracks 101 and 103) that is contributed by main track 102 may be written as y=(1−α−β) y1+α y0+β y2, where α and β are the respective amplitude contributions from tracks 103 and 101.
If y0 and y2, or estimates of y0 and y2, were known, then y1 could be determined by subtracting α y0+β y2 from y, and then dividing by (1−α−β):

 y1=(y−α y0−β y2)/(1−α−β)

This can be simplified if, as shown in FIG. 3, the read head can be positioned so that substantially all of the ITI contribution is derived from only one of the adjacent tracks 103, so that:

 y1=(y−α y0)/(1−α)

A similar result is obtained in the off-track case, as shown in FIG. 4, where the main track is track 402 and the adjacent track which is erroneously partially read is track 403. Again, if y1, y0 are the respective noiseless channel read-back signals corresponding to the two tracks 402, 403 in the absence of OTI, then:

 y1=(y−α y0)/(1−α).

Therefore, if the signal quality degrades, it does not matter whether the degradation results from ITI or OTI. The techniques described herein can be applied to factor out the interference in either case.

Returning to the view of FIG. 3, there will be some track 103 at the edge of the storage medium (e.g., disk drive platter) for which there is no adjacent track to cause ITI and that track can be read to obtain y0. Each subsequent track 102, 101, etc., could then be read, subtracting out the contribution from adjacent track 103, 102, etc. and thereby also providing a respective value of “ y0” for compensating for ITI on each further subsequent track. As a practical matter, if a storage device has a large number of tracks, and the target track is not near the edge of the device, one would not necessarily be able to read all of the tracks from the edge to the track of interest. However, if the track adjacent to the track of interest has not previously been read, it should be possible to read that adjacent track and thereby form at least an estimate for y0 for that adjacent track, even though that estimate may include ITI from a further track.
This can be generalized as follows: If hk represents the channel target, a1(t) and a2(t) represent the main-track bits and adjacent-track bits, respectively, n1(t) and n2(t) represent the main-track jitter noise and adjacent-track jitter noise, respectively, α represents the adjacent-track amplitude factor, τ represents the adjacent-track phase factor, and nawgn represents AWGN read-back noise, then:
ideal main_track signal




  
    
      
        y
        ^
      
      1
    
    ⁡
    
      (
      t
      )
    
  
  =
  
    
      ∑
      k
    
    ⁢
    
      
        h
        k
      
      ·
      
        
          a
          1
        
        ⁡
        
          (
          
            t
            -
            k
          
          )
        
      
    
  




and

ideal adjacent_track signal





  
    
      
        y
        ^
      
      2
    
    ⁡
    
      (
      t
      )
    
  
  =
  
    
      ∑
      k
    
    ⁢
    
      
        h
        k
      
      ·
      
        
          a
          2
        
        ⁡
        
          (
          
            t
            -
            k
          
          )
        
      
    
  




From this we can derive that the total read-back signal from the main track and the adjacent track is




  
    
      
        
          y
          ⁡
          
            (
            t
            )
          
        
        =
        
        ⁢
        
          
            
              (
              
                1
                -
                α
              
              )
            
            ·
            
              
                y
                1
              
              ⁡
              
                (
                t
                )
              
            
          
          +
          
            α
            ·
            
              
                y
                2
              
              ⁡
              
                (
                
                  t
                  -
                  τ
                
                )
              
            
          
          +
          
            
              n
              awgn
            
            ⁡
            
              (
              t
              )
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            
              (
              
                1
                -
                α
              
              )
            
            ·
            
              [
              
                
                  
                    
                      y
                      ^
                    
                    1
                  
                  ⁡
                  
                    (
                    t
                    )
                  
                
                +
                
                  
                    n
                    1
                  
                  ⁡
                  
                    (
                    t
                    )
                  
                
              
              ]
            
          
          +
          
            α
            ·
            
              [
              
                
                  
                    
                      y
                      ^
                    
                    2
                  
                  ⁡
                  
                    (
                    
                      t
                      -
                      τ
                    
                    )
                  
                
                +
                
                  
                    n
                    2
                  
                  ⁡
                  
                    (
                    
                      t
                      -
                      τ
                    
                    )
                  
                
                +
                
                  
                    n
                    awgn
                  
                  ⁡
                  
                    (
                    t
                    )
                  
                
              
              ]
            
          
        
      
    
  




If one multiplies both sides by ŷ2(t), and then takes the expectation on both sides, the result will be:

E[y(t)·ŷ2(t)]=(1−α)·E[ŷ1(t)·ŷ2(t)]+(1−α)·E[n1(t)·ŷ2(t)]+α·E[ŷ2(t−τ)·ŷ2(t)]+α·E[n2(t−τ)·ŷ2(t)]+E[nawgn(t)·ŷ2(t)]

The following terms are uncorrelated and hence are zero:

E[ŷ1(t)·ŷ2(t)]=0

E[n1(t)·ŷ2(t)]=0

E[nawgn(t)·ŷ2(t)]=0

The following term is very small and can be considered to be zero:

E[n2(t−τ)·ŷ2(t)]≈0

This leaves:

E[y(t)·ŷ2(t)]=α·E[ŷ2(t−τ)·ŷ2(t)]

For a band-limited signal ŷ2(t), sampled at greater than or equal to the Nyquist rate, we can write the term ŷ2(t−τ) as:




  
    
      
        y
        ^
      
      2
    
    ⁡
    
      (
      
        t
        -
        τ
      
      )
    
  
  =
  
    
      ∑
      
        i
        =
        ∞
      
      
        i
        =
        
          +
          ∞
        
      
    
    ⁢
    
      
        a
        i
      
      ·
      
        
          
            y
            ^
          
          2
        
        ⁡
        
          (
          
            t
            -
            i
          
          )
        
      
    
  




where ai ∈ sinc(i−τ)

This can be approximated as a finite (2n+1)-tap interpolation filter:





  
    
      
        y
        ^
      
      2
    
    ⁡
    
      (
      
        t
        -
        τ
      
      )
    
  
  ≈
  
    
      ∑
      
        i
        =
        n
      
      
        i
        =
        
          +
          n
        
      
    
    ⁢
    
      
        a
        i
      
      ·
      
        
          
            y
            ^
          
          2
        
        ⁡
        
          (
          
            t
            -
            i
          
          )
        
      
    
  




Substituting, one gets:





  
    E
    ⁡
    
      [
      
        
          y
          ⁡
          
            (
            t
            )
          
        
        ·
        
          
            
              y
              ^
            
            2
          
          ⁡
          
            (
            t
            )
          
        
      
      ]
    
  
  =
  
    
      α
      ·
      E
    
    ⁢
    
      
        ∑
        
          i
          =
          n
        
        
          i
          =
          
            +
            n
          
        
      
      ⁢
      
        
          a
          i
        
        ·
        
          
            
              y
              ^
            
            2
          
          ⁡
          
            (
            
              t
              -
              i
            
            )
          
        
        ·
        
          
            
              y
              ^
            
            2
          
          ⁡
          
            (
            t
            )
          
        
      
    
  




or:





  
    
      E
      ⁡
      
        [
        
          
            
              
                y
                ^
              
              2
            
            ⁡
            
              (
              t
              )
            
          
          ·
          
            
              [
              
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          -
                          n
                        
                        )
                      
                    
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          -
                          n
                          +
                          1
                        
                        )
                      
                    
                  
                
                
                  
                    ⋮
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                  
                
                
                  
                    ⋮
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          +
                          n
                          -
                          1
                        
                        )
                      
                    
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          +
                          n
                        
                        )
                      
                    
                  
                
              
              ]
            
            T
          
        
        ]
      
    
    ·
    
      [
      
        
          
            
              A
              
                -
                n
              
            
          
        
        
          
            
              A
              
                
                  -
                  n
                
                +
                1
              
            
          
        
        
          
            ⋮
          
        
        
          
            
              A
              0
            
          
        
        
          
            ⋮
          
        
        
          
            
              A
              
                n
                -
                1
              
            
          
        
        
          
            
              A
              n
            
          
        
      
      ]
    
  
  =
  
    E
    ⁡
    
      [
      
        
          y
          ⁡
          
            (
            t
            )
          
        
        ·
        
          
            
              y
              ^
            
            2
          
          ⁡
          
            (
            t
            )
          
        
      
      ]
    
  




where Ai=αai.

Instead of multiplying both sides of the expression for y(t) by ŷ2(t), one can multiply both sides by ŷ2(t−i), ∀i:n≦i≦+n, which would yield 2n+1 equations, and which, after then taking the expectation, can be written in matrix form as follows:




  
    
      E
      ⁡
      
        [
        
          
            [
            
              
                
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        -
                        n
                      
                      )
                    
                  
                
              
              
                
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        -
                        n
                        +
                        1
                      
                      )
                    
                  
                
              
              
                
                  ⋮
                
              
              
                
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                
              
              
                
                  ⋮
                
              
              
                
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        +
                        n
                        -
                        1
                      
                      )
                    
                  
                
              
              
                
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        +
                        n
                      
                      )
                    
                  
                
              
            
            ]
          
          ·
          
            
              [
              
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          -
                          n
                        
                        )
                      
                    
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          -
                          n
                          +
                          1
                        
                        )
                      
                    
                  
                
                
                  
                    ⋮
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                  
                
                
                  
                    ⋮
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          +
                          n
                          -
                          1
                        
                        )
                      
                    
                  
                
                
                  
                    
                      
                        
                          y
                          ^
                        
                        2
                      
                      ⁡
                      
                        (
                        
                          t
                          +
                          n
                        
                        )
                      
                    
                  
                
              
              ]
            
            T
          
        
        ]
      
    
    ·
    
      [
      
        
          
            
              A
              
                -
                n
              
            
          
        
        
          
            
              A
              
                
                  -
                  n
                
                +
                1
              
            
          
        
        
          
            ⋮
          
        
        
          
            
              A
              0
            
          
        
        
          
            ⋮
          
        
        
          
            
              A
              
                n
                -
                1
              
            
          
        
        
          
            
              A
              n
            
          
        
      
      ]
    
  
  =
  
    E
    ⁡
    
      [
      
        
          
            
              
                y
                ⁡
                
                  (
                  t
                  )
                
              
              ·
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    -
                    n
                  
                  )
                
              
            
          
        
        
          
            
              
                y
                ⁡
                
                  (
                  t
                  )
                
              
              ·
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    -
                    n
                    +
                    1
                  
                  )
                
              
            
          
        
        
          
            ⋮
          
        
        
          
            
              
                y
                ⁡
                
                  (
                  t
                  )
                
              
              ·
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  t
                  )
                
              
            
          
        
        
          
            ⋮
          
        
        
          
            
              
                y
                ⁡
                
                  (
                  t
                  )
                
              
              ·
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    +
                    n
                    -
                    1
                  
                  )
                
              
            
          
        
        
          
            
              
                y
                ⁡
                
                  (
                  t
                  )
                
              
              ·
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    +
                    n
                  
                  )
                
              
            
          
        
      
      ]
    
  




Or alternatively:





  
    
      
        
          [
          
            
              
                
                  R
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    1
                    )
                  
                
              
              
                ...
              
              
                
                  R
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
              
                ...
              
              
                
                  R
                  ⁡
                  
                    (
                    
                      
                        2
                        ⁢
                        n
                      
                      -
                      1
                    
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    
                      2
                      ⁢
                      n
                    
                    )
                  
                
              
            
            
              
                
                  R
                  ⁡
                  
                    (
                    
                      -
                      1
                    
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                ⋱
              
              
                
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    
                      
                        2
                        ⁢
                        n
                      
                      -
                      1
                    
                    )
                  
                
              
            
            
              
                ⋮
              
              
                ⋮
              
              
                ⋱
              
              
                
                  
                
              
              
                
                  
                
              
              
                ⋱
              
              
                ⋮
              
            
            
              
                
                  R
                  ⁡
                  
                    (
                    
                      -
                      n
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                ⋮
              
            
            
              
                ⋮
              
              
                ⋮
              
              
                ⋱
              
              
                
                  
                
              
              
                ⋱
              
              
                
                  
                
              
              
                ⋮
              
            
            
              
                
                  R
                  ⁡
                  
                    (
                    
                      
                        
                          -
                          2
                        
                        ⁢
                        n
                      
                      +
                      1
                    
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    
                      
                        
                          -
                          2
                        
                        ⁢
                        n
                      
                      +
                      2
                    
                    )
                  
                
              
              
                
                  
                
              
              
                ⋱
              
              
                
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    1
                    )
                  
                
              
            
            
              
                
                  R
                  ⁡
                  
                    (
                    
                      
                        -
                        2
                      
                      ⁢
                      n
                    
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    
                      
                        
                          -
                          2
                        
                        ⁢
                        n
                      
                      +
                      1
                    
                    )
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    
                      -
                      1
                    
                    )
                  
                
              
              
                
                  R
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
            
          
          ]
        
        }
      
          
    ·
    
      
        
           
          
            [
            
              
                
                  
                    A
                    
                      -
                      n
                    
                  
                
              
              
                
                  
                    A
                    
                      
                        -
                        n
                      
                      +
                      1
                    
                  
                
              
              
                
                  ⋮
                
              
              
                
                  
                    A
                    0
                  
                
              
              
                
                  ⋮
                
              
              
                
                  
                    A
                    
                      n
                      -
                      1
                    
                  
                
              
              
                
                  
                    A
                    n
                  
                
              
            
            ]
          
        
        }
      
      A
    
  
  =
  
    
      
        E
        ⁡
        
          [
          
            
              
                
                  
                    y
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                  ·
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        -
                        n
                      
                      )
                    
                  
                
              
            
            
              
                
                  
                    y
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                  ·
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        -
                        n
                        +
                        1
                      
                      )
                    
                  
                
              
            
            
              
                ⋮
              
            
            
              
                
                  
                    y
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                  ·
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                
              
            
            
              
                ⋮
              
            
            
              
                
                  
                    y
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                  ·
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        +
                        n
                        -
                        1
                      
                      )
                    
                  
                
              
            
            
              
                
                  
                    y
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                  ·
                  
                    
                      
                        y
                        ^
                      
                      2
                    
                    ⁡
                    
                      (
                      
                        t
                        +
                        n
                      
                      )
                    
                  
                
              
            
          
          ]
        
      
      }
    
    P
  




where  is the correlation matrix of the ideal adjacent-track signal, A is the interpolation filter, and P is the cross-correlation of the received signal and the ideal adjacent-track signal.
The interpolation filter taps can therefore be obtained by solving the following equation:

A=−1·P 

Correlation matrix terms depend only on the target taps and therefore can be pre-computed once the target is fixed:

Ci=Auto-Correlation([h0 . . . hk])

(i,j)th entry of matrix  is (i,j)=C(|i−j|)

Accordingly, the target signal y′(t) can be obtained by removing the interfering adjacent-track signal as follows:




  
    
      y
      ′
    
    ⁡
    
      (
      t
      )
    
  
  =
  
    
      y
      ⁡
      
        (
        t
        )
      
    
    -
    
      
        
          [
          
            
              
                
                  A
                  
                    -
                    n
                  
                
              
            
            
              
                
                  A
                  
                    
                      -
                      n
                    
                    +
                    1
                  
                
              
            
            
              
                ⋮
              
            
            
              
                
                  A
                  0
                
              
            
            
              
                ⋮
              
            
            
              
                
                  A
                  
                    n
                    -
                    1
                  
                
              
            
            
              
                
                  A
                  n
                
              
            
          
          ]
        
        T
      
      ·
      
        [
        
          
            
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    -
                    n
                  
                  )
                
              
            
          
          
            
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    -
                    n
                    +
                    1
                  
                  )
                
              
            
          
          
            
              ⋮
            
          
          
            
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  t
                  )
                
              
            
          
          
            
              ⋮
            
          
          
            
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    +
                    n
                    -
                    1
                  
                  )
                
              
            
          
          
            
              
                
                  
                    y
                    ^
                  
                  2
                
                ⁡
                
                  (
                  
                    t
                    +
                    n
                  
                  )
                
              
            
          
        
        ]
      
    
  




Thus, if a sector-read operation fails because of OTI or ITI, the sector can be recovered by carrying out the following method:
First, the adjacent-track is read and the decoded adjacent-track bits are stored. If the adjacent track itself is subject to ITI (because a small-track-pitch recording technique such as shingled recording was used), this process may have to iterated until the edge of the medium, or at least a known track, is reached, or an estimate of the adjacent track may have to be used.
Next, the failed sector is re-read and the vector P is computed from the readings. The interpolation filter A is then computed from the matrix −1, which will have been previously pre-computed and stored. The filter A can be used to remove the interfering adjacent-track signal and obtain a corrected signal, and the corrected signal can be decoded to obtain the corrected data from the target track.
As discussed above, in a small-track-pitch situation, ITI contributions might be received from more than one adjacent track. The foregoing discussion has assumed that the read head could be placed in such a position that it would receive ITI contributions from only one adjacent track. However, if the track pitch is very small, it may not be possible to limit the ITI contributions to those from one adjacent track. For such a system, to read a current-track k, in general tracks k−n, k−n+1 . . . , k, . . . , k+n−1, k+n would be processed to remove ITI contributions from tracks k−n, . . . , k−1 and k+1, . . . , k+n.
Indeed, in the embodiment shown in FIG. 5, the track pitch is so small relative to the width of the read head that the read head 105 overlaps five tracks 501-505 (n=2), so to read track 103, one must remove contributions from tracks 101, 102, 104 and 105. Alternatively, such an embodiment may be one that employs two-dimensional coding, where the channel coding runs across tracks as well as along each track, to read more than one track at a time. FIG. 6 shows how the codewords i, i+1, i+2 . . . span multiple tracks 601-608. In such an embodiment, rather than decoding each track after the ITI contribution of its adjacent track or tracks have been removed, all of the tracks spanned by a codeword are processed sequentially, as described above, to remove ITI contributions without decoding any individual track, and then the codeword(s) can be decoded.
It will be appreciated from the methods described above that data from one or more tracks that have been read previously will be used in the process of decoding one or more current tracks. It will further be appreciated that while the discussion above describes reading of the adjacent track before the current track, it is possible to read and store the current track data first, and then to read the adjacent track to determine its ITI contribution. In such a case, unless the adjacent track had been processed previously, an estimate of its ITI contribution may have to be used.
FIG. 7 shows a schematic representation of apparatus 700 for carrying out such methods, which may be used in a storage device such as, e.g., a disk drive. The storage device may have a controller 701 (e.g., a hard disk controller, or HDC, where the device is a hard disk drive) which controls various functions and components of the device (not all of which are shown in FIG. 7). Controller 701 may send read commands 702 to read-data channel 703, which may include at least one detector—e.g., a SOVA detector (not shown)—and at least one decoder—e.g., a Viterbi decoder (not shown).
In accordance with embodiments of the present invention, read-data channel 703 also may include memory, such as RAM 704, for storing decoded data (e.g., NRZ data) from one or more previously-read tracks. As each track is decoded within read-data channel 703, the decoder can reference the data stored in RAM 704 for an adjacent track or tracks, in order to decode the current track or tracks, using the methods described above. The decoded channel data 705 is at least temporarily stored in double-data-rate SDRAM 706 from which it is read at 707 by device controller 701.
Instead of storing the NRZ data from the previously-read track or tracks in RAM 704, if the previous track or tracks were successfully decoded, the actual decoded user bits may be stored in RAM 704, which would consume less space in RAM 704. In such an embodiment, optional encoder 714 would be provided to re-encode the user bits for use in removing ITI from the current track.
In an alternate embodiment such as embodiment 800 shown in FIG. 8, there is no prior track storage in read-data channel 803. Instead read-data channel 803 outputs decoded data to DDR 806 as is known, but instead of retaining that data only temporarily, DDR 806 retains the decoded data for a particular track at least for the duration of the time needed to decode a predetermined number of additional tracks, and possibly “permanently”—i.e., until apparatus 800 is powered down or otherwise reset, or until the available capacity for storing previously-read track data is exceeded, in which case, preferably, the least-recently read track data are overwritten. In such an embodiment, when read-data channel 803 is decoding a particular track, it reads the decoded data 808 for any previous tracks that it needs from DDR 806—e.g., using direct memory access (DMA). The final data are read at 707 by device controller 701, as above. It will be appreciated that DDR 806 may be substantially identical to DDR 706, except in terms of capacity, which would be greater in DDR 806 than in DDR 706 because of the need to store previously-read track data.
As above, instead of storing the NRZ data from the previously-read track or tracks in DDR 806, if the previous track or tracks were successfully decoded, the actual decoded user bits may be stored in DDR 806, which would consume less space in DDR 806. In such an embodiment, optional encoder 814 would be provided to re-encode the user bits for use in removing ITI from the current track.
In the expression above, the ideal adjacent_track signal ŷ2(t) is determined based on the NRZ data ai. However, ŷ2(t) corresponds to the adjacent-track FIR data less noise. Therefore, in a further embodiment 900 shown in FIG. 9, read-data channel 903 outputs decoded data for a given track to DDR 906 as above, but also outputs filter samples 905 (e.g., FIR filter samples) from that given track for storage in DDR 906.
In such an embodiment, when read-data channel 903 is decoding a particular track, it reads either the decoded channel data 908 or the channel filter data 909 for any previous tracks that it needs, or both, from DDR 906. The ITI to be removed from the current track can be determined from either one alone, or a combination derived from both, such as an average, may be used. The final data are read at 707 by device controller 701, as above. It will be appreciated that DDR 906 may be substantially identical to DDR 806, except in terms of capacity, which would be greater in DDR 906 than in DDR 806 because of the need to store filter samples for the previously-read track or tracks, as well as decoded data from that track or tracks. DDR 906 preferably retains the decoded data and the filter samples for a particular track at least for the duration of the time needed to decode a predetermined number of additional tracks, and possibly “permanently”—i.e., until apparatus 900 is powered down or otherwise reset, or until the available capacity for storing previously-read track data is exceeded, in which case, preferably, the least-recently read track data are overwritten.
As above, instead of storing the NRZ data from the previously-read track or tracks in DDR 906, if the previous track or tracks were successfully decoded, the actual decoded user bits may be stored in DDR 906, which would consume less space in DDR 906. In such an embodiment, optional encoder 914 would provided to re-encode the user bits for use in removing ITI from the current track.
A data storage system 1000 may include a storage medium such as a hard disk 1001 having a plurality of tracks 1002 which may be subject to potential ITI or OTI. System 1000 also may include a read head 1003, a detector 1004, and controller apparatus 1005, which may, for example, be any one of apparatus 700, 800 or 900.
Thus it is seen that a data storage system, and method of decoding stored data, in which contributions from one or more adjacent tracks may be accounted for in decoding one or more tracks of interest, has been provided.
It will be understood that the foregoing is only illustrative of the principles of the invention, and that the invention can be practiced by other than the described embodiments, which are presented for purposes of illustration and not of limitation, and the present invention is limited only by the claims which follow.

## Claims

1. A method for reading a current track of data from a storage device, the method comprising:
reading an adjacent track of data;
decoding data from the adjacent track of data;
reading data from the current track of data; and
decoding the data read from the current track of data, based on the decoded data from the adjacent track of data, including deriving an interpolation filter from the decoded data from the adjacent track of data by:
deriving a correlation matrix from the decoded data from the adjacent track of data,
deriving a vector from the data from the current track of data, and
combining the correlation matrix and the vector.

2. The method of claim 1 wherein decoding the data read from the current track, based on the decoded data from the adjacent track of data further comprises:
determining adjacent track data amplitude;
determining adjacent track data phase-shift; and
computing an adjacent track signal portion using the adjacent track data amplitude and the adjacent track data phase-shift.

3. The method of claim 1 wherein the combining comprises multiplying.

4. The method of claim 3 wherein the deriving an interpolation filter from the decoded data from the adjacent track of data further comprises inverting the correlation matrix before the multiplying.

5. The method of claim 1 wherein the deriving an interpolation filter from the decoded data from the adjacent track of data further comprises inverting the correlation matrix before the combining.

6. The method of claim 1 wherein:
the adjacent track of data comprises a plurality of adjacent tracks of data; and
the reading data from the current track comprises positioning a read head to read data from the current track and only one adjacent track.

7. The method of claim 1 wherein:
the current track of data comprises a plurality of current tracks of data; and
the decoding the data from the current track comprises two-dimensional decoding.

8. The method of claim 1 wherein the decoding is based on inter-track interference.

9. The method of claim 1 wherein the decoding is based on off-track interference.

10. A storage controller comprising:
a device controller; and
a read data channel including a decoder for decoding output of a detector; wherein:
the detector is configured to read data requested from a storage medium by said device controller;
the storage medium has a plurality of tracks of data thereon; and
when said device controller is configured to request data from a current track of data on said storage medium:
said detector is configured to read an adjacent track of data,
said decoder is configured to decode data from the adjacent track of data,
said detector is configured to also read data from the current track, and
said decoder is configured to also decode the data read from the current track, based on the decoded data from the adjacent track of data, including deriving an interpolation filter from the decoded data from the adjacent track of data by:
deriving a correlation matrix from the decoded data from the adjacent track of data,
deriving a vector from the data from the current track, and
combining the correlation matrix and the vector.

11. The storage controller of claim 10 further comprising memory for storing said data from the adjacent track of data.

12. The storage controller of claim 11 wherein said memory is in said read data channel.

13. The storage controller of claim 11 wherein said memory is separate from said read data channel.

14. The storage controller of claim 10 wherein:
the read data channel decodes the data read from the current track by further:
determining adjacent track data amplitude;
determining adjacent track data phase-shift, and
computing an adjacent track signal portion using the adjacent track data amplitude and the adjacent track data phase-shift.

15. The storage controller of claim 10 wherein the combining comprises multiplying.

16. The storage controller of claim 15 wherein the decoder of the read data channel inverts the correlation matrix before the multiplying.

17. The storage controller of claim 10 wherein the decoder of the read data channel inverts the correlation matrix before the combining.

18. The storage controller of claim 10 wherein the decoding is based on inter-track interference.

19. The storage controller of claim 10 wherein the decoding is based on off-track interference.