# Patent

## Title
Adaptive soft-output detector for magnetic tape read channels

## Abstract

In accordance with one embodiment, a data storage system includes a tape channel for reading precoded data from a magnetic tape medium to produce a signal, a soft detector adapted for calculating first soft information about each bit of the signal and sending the first soft information to a soft decoder, and the soft decoder positioned subsequent to the soft detector, the soft decoder being adapted for calculating second soft information about each bit of the signal and sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium, and wherein the soft detector provides automatic compensation for the precoded data. Other systems, methods, and computer program products for reading data using an adaptive soft-output detector are described according to more embodiments.

## Background
BACKGROUND
The present invention relates to data storage using magnetic tape channels, and more particularly, to reading data using an adaptive soft-output detector in the magnetic tape read channels.
A conventional data flow 200 for reading data from a magnetic tape is shown in FIG. 2, according to the prior art. The tape channel 202 receives data that has passed through an error correction code (ECC) encoder and a modulation code (MC) encoder prior to being stored to magnetic tape. Then, the tape channel 202 reads the data as bits xk, (either a 0 or a 1), noise nk is injected into the signal to become a signal yk that is read by the hard detector 204. This detection utilizes a hard detector 204, which does not incorporate soft information in its detecting scheme.
Soft information may be considered a probability that a detected bit (0 or 1) is actually a 0 or a 1. There are different types of probabilities that may be implemented in a data flow, but any data flow which uses probabilities (soft information) for decoding must utilize soft detection. However, soft detection in magnetic tape recording channels have typically suffered from some problems. Two types of soft detection typically used are BCJR, which is named after its inventors, Bahl, Cocke, Jelinek, and Raviv, and Dual-Max, which is a derivative (simplified version) of BCJR that relies on a specific set of assumptions.
However, each of these algorithms experience issues when implemented in data flows for magnetic tape recording channels. Accordingly, it would be beneficial to have a soft detector that is capable of operating in magnetic tape recording channel data flow that alleviates the issues associated with known algorithms.
BRIEF SUMMARY
In one embodiment, a data storage system includes a tape channel for reading precoded data from a magnetic tape medium to produce a signal, a soft detector adapted for calculating first soft information about each bit of the signal and sending the first soft information to a soft decoder, and the soft decoder positioned subsequent to the soft detector, the soft decoder being adapted for calculating second soft information about each bit of the signal and sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium, and wherein the soft detector provides automatic compensation for the precoded data.
In another embodiment, a method includes reading precoded data from a magnetic tape medium to produce a signal, passing the signal through a soft detector to calculate first soft information about each bit of the signal and to provide adaptive compensation for the precoded data, sending the first soft information to a soft decoder, passing the signal through the soft decoder to calculate second soft information about each bit of the signal, and sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium.
In yet another embodiment, a computer program product includes a computer readable storage medium having computer readable program code embodied therewith, the computer readable program code including computer readable program code configured for reading precoded data from a magnetic tape medium to produce a signal, computer readable program code configured for passing the signal through a soft detector to calculate first soft information about each bit of the signal and to provide adaptive compensation for the precoded data, computer readable program code configured for sending the first soft information to a soft decoder, computer readable program code configured for passing the signal through the soft decoder to calculate second soft information about each bit of the signal, and computer readable program code configured for sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium.
Any of these embodiments may be implemented in a magnetic data storage system such as a tape drive system, which may include a magnetic head, a drive mechanism for passing a magnetic medium (e.g., recording tape) over the magnetic head, and a controller electrically coupled to the magnetic head.
Other aspects and embodiments of the present invention will become apparent from the following detailed description, which, when taken in conjunction with the drawings, illustrates by way of example the principles of the invention.



BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS
FIG. 1 illustrates a simplified tape drive of a tape-based data storage system, according to one embodiment.
FIG. 2 shows a data flow for a magnetic tape recording channel, according to the prior art.
FIG. 3 is a partial data flow for BCJR detection, according to the prior art.
FIG. 4 is a partial reverse Concatenation architecture with soft detection and soft decoding, according to one embodiment.
FIG. 5 is a system for exchanging soft information for a magnetic tape recording channel, according to one embodiment.
FIG. 6 shows Viterbi-algorithm-like computation on a channel trellis forward and backward in time, according to one embodiment.
FIG. 7 shows one embodiment of a soft detection/decoding system using a noise predictive soft Dual-MAX (DMAX), according to one embodiment.
FIG. 8 shows an adaptive whitening filter coefficient updater, according to one embodiment.
FIG. 9 shows a soft detection/decoding system using a soft noise-predictive data-dependent (DD) DMAX detector, according to one embodiment.
FIG. 10 shows an adaptive whitening filter coefficient updater, according to one embodiment.
FIG. 11 shows one embodiment of a soft detection/decoding system which uses a soft detector that provides adaptive compensation for the presence of a precoded tape channel, according to one embodiment.
FIG. 12 shows one embodiment of a precoded tape channel.
FIG. 13 shows one embodiment of a soft detection/decoding system which uses a soft detector that provides adaptive compensation for the presence of a precoded tape channel, according to one embodiment.
FIG. 14 shows one embodiment of a precoded tape channel.
FIG. 15 shows examples of trellis structures according to various embodiments.



DETAILED DESCRIPTION
The following description is made for the purpose of illustrating the general principles of the present invention and is not meant to limit the inventive concepts claimed herein. Further, particular features described herein can be used in combination with other described features in each of the various possible combinations and permutations.
Unless otherwise specifically defined herein, all terms are to be given their broadest possible interpretation including meanings implied from the specification as well as meanings understood by those skilled in the art and/or as defined in dictionaries, treatises, etc.
It must also be noted that, as used in the specification and the appended claims, the singular forms “a,” “an,” and “the” include plural referents unless otherwise specified.
In one general embodiment, a data storage system includes a tape channel for reading precoded data from a magnetic tape medium to produce a signal, a soft detector adapted for calculating first soft information about each bit of the signal and sending the first soft information to a soft decoder, and the soft decoder positioned subsequent to the soft detector, the soft decoder being adapted for calculating second soft information about each bit of the signal and sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium, and wherein the soft detector provides automatic compensation for the precoded data.
In another general embodiment, a method includes reading precoded data from a magnetic tape medium to produce a signal, passing the signal through a soft detector to calculate first soft information about each bit of the signal and to provide adaptive compensation for the precoded data, sending the first soft information to a soft decoder, passing the signal through the soft decoder to calculate second soft information about each bit of the signal, and sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium.
In yet another general embodiment, a computer program product includes a computer readable storage medium having computer readable program code embodied therewith, the computer readable program code including computer readable program code configured for reading precoded data from a magnetic tape medium to produce a signal, computer readable program code configured for passing the signal through a soft detector to calculate first soft information about each bit of the signal and to provide adaptive compensation for the precoded data, computer readable program code configured for sending the first soft information to a soft decoder, computer readable program code configured for passing the signal through the soft decoder to calculate second soft information about each bit of the signal, and computer readable program code configured for sending the second soft information to the soft detector, wherein the precoded data includes a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium.
As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as “logic,” a “circuit,” a “module,” or a “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.
Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a non-transitory computer readable storage medium. A non-transitory computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any non-transitory, tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device, such as an electrical connection having one or more wires, an optical fiber, etc.
Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
Aspects of the present invention are described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
FIG. 1 illustrates a simplified tape drive 100 of a tape-based data storage system, which may be employed according to various embodiments. While one specific implementation of a tape drive is shown in FIG. 1, it should be noted that the embodiments described herein may be implemented in the context of any type of tape drive system.
As shown, a tape supply cartridge 120 and a take-up reel 121 are provided to support a tape 122. One or more of the reels may form part of a removable cassette and are not necessarily part of the system 100. The tape drive, such as that illustrated in FIG. 1, may further include drive motor(s) to drive the tape supply cartridge 120 and the take-up reel 121 to move the tape 122 over a tape head 126 of any type. The tape 122 may be a linear tape open (LTO) format or any other suitable magnetic tape medium known in the art.
Guides 125 guide the tape 122 across the tape head 126. Such tape head 126 is in turn coupled to a controller assembly 128 via a cable 130. The controller 128 typically comprises a servo channel and controls head functions, such as track following, writing, reading, etc. The cable 130 may include read/write circuits to transmit data to the head 126 to be recorded on the tape 122 and to receive data read by the head 126 from the tape 122. An actuator 132 determines position of the head 126 relative to the tape 122.
An interface 134 may also be provided for communication between the tape drive and a host (integral or external) to send and receive the data and for controlling the operation of the tape drive and communicating the status of the tape drive to the host, all as will be understood by those of skill in the art.
BCJR soft detection relies on the a posteriori probability (APP) of states and state transitions in a channel finite-state machine, and adheres to the flow shown in FIG. 3. The ISI channel 302 is described by a trellis diagram with state Skε{0, 1, . . . , 2L−1} at time k. The joint probability density p(Sk−1, Sk, Y1N) plays a central role in the algorithm because of the following relationship, where the summation occurs over all trellis branches for which ak=+1 (as shown) and −1.




  
    P
    ⁡
    
      (
      
        
          a
          k
        
        =
        
          
            +
            1
          
          |
          
            Y
            1
            N
          
        
      
      )
    
  
  ∼
  
    
      ∑
      
        
          
            S
            
              k
              -
              1
            
          
          →
          
            S
            k
          
        
        
          
            a
            k
          
          =
          
            +
            1
          
        
      
    
    ⁢
    
      p
      ⁡
      
        (
        
          
            S
            
              k
              -
              1
            
          
          ,
          
            S
            k
          
          ,
          
            Y
            1
            N
          
        
        )
      
    
  




The BCJR detector 304 factors a joint probability density as follows, where the first term is computed through forward recursion, the second term is the branch transition probability, and the third term is computed through backward recursion.




Forward Recursion:





  
    
      
        α
        _
      
      k
    
    ⁡
    
      (
      
        S
        k
      
      )
    
  
  =
  
    
      ∑
      
        S
        
          k
          -
          1
        
      
    
    ⁢
    
      
        
          
            γ
            _
          
          k
        
        ⁡
        
          (
          
            
              S
              
                k
                -
                1
              
            
            ,
            
              S
              k
            
          
          )
        
      
      ·
      
        
          
            α
            _
          
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
    
  




Branch Transition Probability:




  
    
      p
      ⁡
      
        (
        
          
            
              y
              k
            
            |
            
              S
              
                k
                -
                1
              
            
          
          ,
          
            S
            k
          
        
        )
      
    
    =
    
      
        1
        
          
            
              2
              ⁢
              
                
              
              ⁢
              π
            
          
          ⁢
          σ
        
      
      ⁢
      
        e
        
          
            
              -
              
                
                  (
                  
                    
                      y
                      k
                    
                    -
                    
                      x
                      k
                    
                  
                  )
                
                2
              
            
            /
            2
          
          ⁢
          
            
          
          ⁢
          
            σ
            2
          
        
      
    
  




  
    
      P
      ⁡
      
        (
        
          
            S
            k
          
          |
          
            S
            
              k
              -
              1
            
          
        
        )
      
    
    =
    
      P
      ⁡
      
        (
        
          a
          k
        
        )
      
    
  



Reverse Recursion:





  
    
      
        β
        _
      
      
        k
        -
        1
      
    
    ⁡
    
      (
      
        S
        
          k
          -
          1
        
      
      )
    
  
  =
  
    
      ∑
      
        S
        k
      
    
    ⁢
    
      
        
          
            γ
            _
          
          k
        
        ⁡
        
          (
          
            
              S
              
                k
                -
                1
              
            
            ,
            
              S
              k
            
          
          )
        
      
      ·
      
        
          
            β
            _
          
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
    
  




The BCJR algorithm uses a maximum a posteriori (MAP) detection rule, where the binary value âk is selected that yields the larger APP according to either the likelihood ratio (LR) or the log likelihood ratio (LLR), as follows.




  
    LR
    ⁡
    
      (
      
        a
        k
      
      )
    
  
  =
  
    
      
        P
        ⁡
        
          (
          
            
              a
              k
            
            =
            
              
                +
                1
              
              |
              
                Y
                1
                N
              
            
          
          )
        
      
      
        P
        ⁡
        
          (
          
            
              a
              k
            
            =
            
              
                -
                1
              
              |
              
                Y
                1
                N
              
            
          
          )
        
      
    
    ⁢
    
      
    
    ⟶
    
      
    
    ⁢
    
      {
      
        
          
            
              
                
                  
                    
                      
                        LR
                        ⁡
                        
                          (
                          
                            a
                            k
                          
                          )
                        
                      
                      ≥
                      1
                    
                    ⇒
                    
                      
                        a
                        ^
                      
                      k
                    
                  
                  =
                  
                    +
                    1
                  
                
              
            
            
              
                
                  
                    
                      
                        LR
                        ⁡
                        
                          (
                          
                            a
                            k
                          
                          )
                        
                      
                      <
                      1
                    
                    ⇒
                    
                      
                        a
                        ^
                      
                      k
                    
                  
                  =
                  
                    -
                    1
                  
                
              
            
          
          ⁢
          
            

          
          ⁢
          
            LLR
            ⁡
            
              (
              
                a
                k
              
              )
            
          
        
        =
        
          ln
          ⁢
          
            
              
                P
                ⁡
                
                  (
                  
                    
                      a
                      k
                    
                    =
                    
                      
                        +
                        1
                      
                      |
                      
                        Y
                        1
                        N
                      
                    
                  
                  )
                
              
              
                P
                ⁡
                
                  (
                  
                    
                      a
                      k
                    
                    =
                    
                      
                        -
                        1
                      
                      |
                      
                        Y
                        1
                        N
                      
                    
                  
                  )
                
              
            
            ⁢
            
              
            
            ⟶
            
              
            
            ⁢
            
              {
              
                
                  
                    
                      
                        
                          
                            LLR
                            ⁡
                            
                              (
                              
                                a
                                k
                              
                              )
                            
                          
                          ≥
                          0
                        
                        ⇒
                        
                          
                            a
                            ^
                          
                          k
                        
                      
                      =
                      
                        +
                        1
                      
                    
                  
                
                
                  
                    
                      
                        
                          
                            LLR
                            ⁡
                            
                              (
                              
                                a
                                k
                              
                              )
                            
                          
                          <
                          0
                        
                        ⇒
                        
                          
                            a
                            ^
                          
                          k
                        
                      
                      =
                      
                        -
                        1
                      
                    
                  
                
              
            
          
        
      
    
  




The BCJR may be advantageously formulated in the log domain, such that the following relationships are created.



  
    
      
    
    ⁢
    
      
        
          
            
              α
              _
            
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        ⁢
                ⁢
        
          
            α
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
      
      =
      
        ln
        ⁡
        
          [
          
            
              
                α
                _
              
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
          ]
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          
            
              β
              _
            
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        ⁢
                ⁢
        
          
            β
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
      
      =
      
        ln
        ⁡
        
          [
          
            
              
                β
                _
              
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
          ]
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          
            
              γ
              _
            
            k
          
          ⁡
          
            (
            
              
                S
                
                  k
                  -
                  1
                
              
              ,
              
                S
                k
              
            
            )
          
        
        ⁢
                ⁢
        
          
            γ
            k
          
          ⁡
          
            (
            
              
                S
                
                  k
                  -
                  1
                
              
              ,
              
                S
                k
              
            
            )
          
        
      
      =
      
        ln
        ⁡
        
          [
          
            
              
                γ
                _
              
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
          ]
        
      
    
  




  
    
      p
      ⁡
      
        (
        
          
            S
            
              k
              -
              1
            
          
          ,
          
            S
            k
          
          ,
          
            Y
            1
            N
          
        
        )
      
    
    =
    
      
        
          
            
              α
              _
            
            
              k
              -
              1
            
          
          ⁡
          
            (
            
              S
              
                k
                -
                1
              
            
            )
          
        
        ⁢
        
          
            
              γ
              _
            
            k
          
          ⁡
          
            (
            
              
                S
                
                  k
                  -
                  1
                
              
              ,
              
                S
                k
              
            
            )
          
        
        ⁢
        
          
            
              β
              _
            
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        ⁢
                ⁢
        p
        ⁢
        
          (
          
            
              S
              
                k
                -
                1
              
            
            ,
            
              
                S
                
                  k
                  ,
                
              
              ⁢
              
                Y
                1
                N
              
            
          
          )
        
      
      =
      
        e
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              γ
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
          +
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
      
    
  




  
    
      LR
      ⁡
      
        (
        
          a
          k
        
        )
      
    
    =
    
      
        
          
            P
            ⁡
            
              (
              
                
                  a
                  k
                
                =
                
                  
                    +
                    1
                  
                  |
                  
                    Y
                    1
                    N
                  
                
              
              )
            
          
          
            P
            ⁡
            
              (
              
                
                  a
                  k
                
                =
                
                  
                    -
                    1
                  
                  |
                  
                    Y
                    1
                    N
                  
                
              
              )
            
          
        
        ⁢
                ⁢
        
          LLR
          ⁡
          
            (
            
              a
              k
            
            )
          
        
      
      =
      
        ln
        ⁢
        
          
            P
            ⁡
            
              (
              
                
                  a
                  k
                
                =
                
                  
                    +
                    1
                  
                  |
                  
                    Y
                    1
                    N
                  
                
              
              )
            
          
          
            P
            ⁡
            
              (
              
                
                  a
                  k
                
                =
                
                  
                    -
                    1
                  
                  |
                  
                    Y
                    1
                    N
                  
                
              
              )
            
          
        
      
    
  



Another algorithm that may be used in soft detection is called a Dual-Max algorithm, which is based on BCJR with some modifications and simplifications. A simplified (sub-optimum) algorithm is obtained based on the following approximation.




  
    ln
    [
    
      
        ∑
        i
      
      ⁢
      
        e
        
          δ
          i
        
      
    
    ]
  
  ≅
  
    
      max
      i
    
    ⁢
    
      δ
      i
    
  




Then, the max-Log-MAP (Dual-Max or DMAX) algorithm may be modeled as follows:



  
    
      
    
    ⁢
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      ≅
      
        
          max
          
            S
            
              k
              -
              1
            
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                α
                
                  k
                  -
                  1
                
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
          
          }
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      ≅
      
        
          max
          
            S
            k
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                β
                k
              
              ⁡
              
                (
                
                  S
                  k
                
                )
              
            
          
          }
        
      
    
  




  
    
      LLR
      ⁡
      
        (
        
          a
          k
        
        )
      
    
    ≅
    
      
        
          max
          
            
              
                S
                
                  k
                  -
                  1
                
              
              →
              
                S
                k
              
            
            
              
                a
                k
              
              =
              
                +
                1
              
            
          
        
        ⁢
        
          {
          
            
              
                α
                
                  k
                  -
                  1
                
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
            +
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                β
                k
              
              ⁡
              
                (
                
                  S
                  k
                
                )
              
            
          
          }
        
      
      -
      
        
          max
          
            
              
                S
                
                  k
                  -
                  1
                
              
              →
              
                S
                k
              
            
            
              
                a
                k
              
              =
              
                -
                1
              
            
          
        
        ⁢
        
          {
          
            
              
                α
                
                  k
                  -
                  1
                
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
            +
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                β
                k
              
              ⁡
              
                (
                
                  S
                  k
                
                )
              
            
          
          }
        
      
    
  



A partial reverse concatenation architecture 400 with soft detection 402 and soft decoding 404 is shown in FIG. 4, according to one embodiment. In this architecture, C2 encoding is performed on data, then MC encoding, and then C1 encoding prior to being written to a magnetic tape medium. Then, in reading data from the tape via the tape channel, signal xk is read with added noise nk to yield the signal yk which is then sent to the soft detector 402. The soft detector calculates and sends soft information about the bit sequence {ak} 406 to the soft C1 decoder 404. The soft C1 decoder 404 then calculates and sends soft information about the bit sequence {ak} 408 back to the soft detector 402, thereby creating an iterative loop. As the number of iterations increases, so does the detection accuracy of the bits in the bit sequence {ak}. In one embodiment, the soft detector 402 may have 2L states, as determined by the number of states of the tape channel.
A system 500 for exchanging soft information for a magnetic tape recording channel may be as shown in FIG. 5, according to one embodiment. In this embodiment, a soft detector 402 (which may be a DMAX detector) provides a log likelihood ratio (LLR) to calculate a posteriori probabilities (APPs) 502 along with each read bit to a soft decoder 404 (which may be a low-density parity check (LPDC) decoder) which in turn provides the LLR to calculate a priori probabilities 504 of the bytes to the soft detector 402. Other types of soft detectors and soft decoders may be used as known in the art.
As indicated above, the detection operations involve a forward computation step and a backward computation step. These steps can be thought of as corresponding to running a Viterbi-algorithm-like computation on a channel trellis forward and backward in time. One example is illustrated in FIG. 6, according to one embodiment.
In FIG. 6, it is assumed that a codeword having a block of N signal samples y1, . . . , yN is received at the soft detector. Upper diagram 602 shows a part of the algorithm that is applied forward in time assuming, for illustrative purposes, a simple 4-state trellis; state values at initial time 0 are denoted by S0 and state values at final time N are denoted by SN. The forward algorithm computes a set of values denoted by α0, α1, . . . , αN. Middle diagram 604 shows the backward pass, where the quantities βN, . . . , β2, β1 are computed on the same trellis. Lower diagram 606 shows that by combining the values obtained in the forward and backward passes (α0, α1, . . . , αN and β1, β2, . . . , βN), it is possible to compute soft information (which is shown as a log-likelihood ratio LLR) on the individual bits ak that form the codeword being processed. These LLR values may then be passed to the soft decoder, in one embodiment. Of course, in other approaches, other soft information may be calculated, such as other likelihood calculations, as would be known to one of skill in the art.
In the embodiments described in FIGS. 7-10, the soft detector uses a DMAX detection algorithm. Additionally, for the methods described below according to various embodiments, it is assumed that the DMAX detector is used at least twice: once in a first initial pass after receiving input signal samples where detection does not include using soft information from the soft decoder; and another time in at least a second pass where soft information provided by the soft decoder is used to detect the block of signal samples.
Referring now to FIG. 7, one embodiment of a soft detection/decoding system 700 using a noise predictive soft DMAX detector 702 is shown. After bits of data are read from the tape via the tape channel 202, where xk=ak+f1ak−1+ . . . +fLak−L, the signal xk affected by noise nk (which may be colored noise in some approaches) is denoted by yk (which equals xk+nk). Signal yk is then subsequently input to a noise whitening filter 704. The output zk of the noise Whitening filter 704 is then input to the soft detector 402 which provides a LLR to calculate APPs along with each read bit (shown as output 406) to the soft decoder 404. The soft decoder 404 next calculates a LLR for each bit to provide the APPs of the bits to the soft detector 402. In one embodiment, the soft detector 402 may be a DMAX soft detector, as described herein in more detail.
In one embodiment, a noise predictive soft DMAX detector 702 (which includes the noise whitening filter 704 and the soft detector 402) may have 2L+λ states, where L and λ represent the memory length of the channel 202 and the noise whitening filter 704, respectively. This is because each of the L and λ memory units corresponding to the channel and the whitening filter, respectively, are capable of storing a binary value of 0 or 1, and accordingly the noise predictive soft DMAX detector 702 may have a total of 2L+λ states.
The noise whitening filter 704 attempts to minimize the variance of the noise affecting the signal zk that is input to the detector 702. In one approach, the whitening filter 704 may apply the following transfer function (polynomial) to yk: W(D)=1−(p1D+ . . . +p80 Dλ), where D represents delay corresponding to a bit duration, and the tape channel 202 itself is characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLDL.
The noise variance term now refers to the noise as seen at the output of the whitening filter 704, and the branch metric mk(Sk−1, Sk) used by the detector 702, according to one embodiment, may be represented by:




  
    
      m
      k
    
    ⁡
    
      (
      
        
          S
          
            k
            -
            1
          
        
        ,
        
          S
          k
        
      
      )
    
  
  =
  
    
      -
      
        
          
            (
            
              
                z
                k
              
              -
              
                w
                k
              
            
            )
          
          2
        
        
          2
          ⁢
          
            
          
          ⁢
          
            σ
            p
            2
          
        
      
    
    +
    
      ln
      ⁢
      
        
      
      ⁢
      
        P
        ⁡
        
          (
          
            a
            k
          
          )
        
      
    
  




with the prediction noise variance being σp2, wk being an ideal nominal signal associated with transition from state Sk−1 to state Sk, and zk being the actual output of the noise whitening filter.

In more embodiments, more than one whitening filter 704 may be employed. For example, 2, 4, 8, 16, 32, 64, or more whitening filters 704 may be employed, such as in a bank of whitening filters. There may be M whitening filters 704 in the bank of whitening filters. In one approach, M may equal the number of branches of the soft detector 402 trellis, e.g., a number of state transitions of the soft detector 402, such as 2L+λ+1 filters.
According to another embodiment, the noise-predictive soft DMAX detector 702 may have normalization applied thereto. When the DMAX algorithm is normalized, the α (forward) and β (backward) variables may be represented with a predetermined finite number of bits as opposed to the values of these variables growing in magnitude without bound, as is possible using conventional DMAX algorithms. In addition, and advantageously, normalization does not affect LLR values. One normalization operation is shown below:




  
    
      α
      k
    
    ⁡
    
      (
      
        S
        k
      
      )
    
  
  =
  
    
      max
      
        S
        
          k
          -
          1
        
      
    
    ⁢
    
      
        {
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            1
          
          ,
          ...
          ⁢
          
            
          
          ,
          N
        
        )
      
    
  




Normalization: find




  
    
      A
      k
    
    =
    
      
        max
        
          S
          k
        
      
      ⁢
      
        {
        
          
            α
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        }
      
    
  
  ,
  
    

  
  ⁢
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
    
    →
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      -
      
        
          A
          k
        
        ⁢
        
          
        
        ⁢
        
          ∀
          
            
              α
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
      
    
  








  
    
      β
      
        k
        -
        1
      
    
    ⁡
    
      (
      
        S
        
          k
          -
          1
        
      
      )
    
  
  =
  
    
      max
      
        S
        k
      
    
    ⁢
    
      
        {
        
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        
          (
          
            
              k
              =
              N
            
            ,
            ...
            ⁢
            
              
            
            ,
            2
          
          )
        
        .
      
    
  




Normalization: find




  
    
      B
      
        k
        -
        1
      
    
    =
    
      
        max
        
          S
          
            k
            -
            1
          
        
      
      ⁢
      
        {
        
          
            β
            
              k
              -
              1
            
          
          ⁡
          
            (
            
              S
              
                k
                -
                1
              
            
            )
          
        
        }
      
    
  
  ,
  
    

  
  ⁢
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
    
    →
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      -
      
        
          B
          
            k
            -
            1
          
        
        ⁢
        
          
        
        ⁢
        
          ∀
          
            
              β
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
        
      
    
  




Of course, other algorithms for normalization may be possible as well, according to other embodiments.

In another embodiment; reduced state detection may be performed. As previously indicated, the soft detector 402 may have 2L+λ states. It is possible to use a longer whitening filter 704 and still keep 2L+λ states in the detector trellis using reduced-state detection. In one approach, the whitening filter 704 may apply the following transfer polynomial to yk: W(D)=1−(p1D+ . . . +pλ′Dλ′), where λ′ is greater than λ and assuming that the tape channel 202 itself is characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLDL.
In this case, the bits defining states Sk−1 and Sk are not enough to specify the bit string of length L+λ+1 needed to compute the system output zk. Therefore, the missing bit(s) are taken from the path memory associated with each state Sk−1. The branch metric mk(Sk−1, Sk) may then be written as follows:




  
    
      m
      k
    
    ⁡
    
      (
      
        
          S
          
            k
            -
            1
          
        
        ,
        
          S
          k
        
      
      )
    
  
  =
  
    
      -
      
        
          
            {
            
              
                z
                k
              
              -
              
                
                  w
                  k
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
            
            }
          
          2
        
        
          2
          ⁢
          
            
          
          ⁢
          
            σ
            p
            2
          
        
      
    
    +
    
      ln
      ⁢
      
        
      
      ⁢
      
        P
        ⁡
        
          (
          
            a
            k
          
          )
        
      
    
  




where the notation wk(Sk−1) indicates that the bit pattern that defines wk, which is an ideal nominal signal associated with transition from state Sk−1 to state Sk, also depends on the path memory associated with the previous state Sk−1, the prediction noise variance is σp2, and zk is the actual output of the noise whitening filter.

In one embodiment, the whitening filter coefficients p1, p2, . . . , pλ may be estimated adaptively as shown in FIG. 8, a simplified version of which is described in U.S. Pat. No. 8,077,764, which is herein incorporated by reference. Referring again to FIG. 8, the whitening filter coefficients p1, p2, . . . , pλ, may be updated using a whitening filter coefficient updater 802 as follows (λ=2 is shown for simplicity in FIG. 8):

p1←p1+αek{circumflex over (n)}k−1 

p2←p2+αek{circumflex over (n)}k−2 

where α is the adaptation stepsize, ek is the error signal, and {circumflex over (n)}k−1, {circumflex over (n)}k−2 are the noise estimates at previous time instants. The corresponding whitening function may be defined as follows:

W(D)=1−(p1D+p2D2)

Furthermore, the error signal ek may be input to a prediction noise variance computation 804 where prediction noise variance σp2 is computed based on the error signal ek, and a small number c (e.g., 0.001). In the embodiment shown in FIG. 8, the last calculated prediction noise variance σp2 is used to calculate the next (updated) prediction noise variance σp2.
However, the noise which exists at the output of the tape channel is not just colored noise, but may also include data dependent noise, which is common in magnetic recording. Accordingly, the soft detector may be devised to take into account this data dependent noise, and therefore do a better job in detecting the bits in the signal. The data dependent nature of the noise may be taken into account in the detection process to achieve better performance in detecting the bits.
The noise that generally affects magnetic data recording systems is either electronics noise or medium noise. It is a combination of these noise sources that produces noise that is difficult to remove from the signal. Noise from the electronics may be either white or colored, but it is not data dependant. The medium noise is a data dependent noise: this type of noise is specific to magnetic recording channels because it corresponds to the written transition in the medium and the position and/or the width of the transition may be variable. There is no certainty in how long the transition is, where the transition is positioned, etc. In addition, if a transition is not written, then this type of noise will not affect the readback signal from the medium.
This is why medium noise is actually data dependent, because a transition is actually written when there is a transition between bits and it is only then that medium noise will manifest itself. To accommodate for this, instead of having only one noise whitening filter as previously described in relation to FIG. 7, more than one noise whitening filter may be present, such as two, four, eight, sixteen, etc., and each of these noise whitening filters is conducting filtering based on a unique possible data pattern being read. For example, the noise whitening filter coefficients may correspond to the particular data pattern associated with that particular noise whitening filter. In one example, if the detector is attempting to determine the likelihood of ak and ak−1, which may be 0 0, 0 1, 1 0, or 1 1, four noise whitening filters may be used, one dependent on each of the possible data patterns. For the four noise whitening filter outputs each corresponding to one of the four possible data patterns, the likelihood of each data pattern is computed by the soft detector. For example, the soft DMAX detector receives outputs from each of the noise whitening filters in the bank of noise whitening filters and calculates a likelihood of a data pattern associated with each of the outputs. Accordingly, the filtering is data dependent, since each noise whitening filter is tailored to be specific to a particular data pattern.
Referring now to FIG. 9, one embodiment of a soft detection/decoding system 900 using a soft noise-predictive data-dependent (DD) DMAX detector 902 is shown. As shown, multiple whitening filters 704 are used in a bank of whitening filters 906. However, this is not required, as a single whitening filter 704 may be used, or any number thereof, e.g., 2, 4, 8, 16, 32, 64, or more.
Magnetic recording systems are typically affected by electronics noise as well as medium noise from the tape medium itself. Medium noise results primarily from transition position/width variations encountered during recording operations. Since positions and shapes of magnetization transitions are determined by the symbols to be written as bits on the tape medium, medium noise depends on the input data sequence, as understood by those of skill in the art.
As previously described, the soft DD-DMAX detector 904 may have 2L+λ states, and there are M=2L+2+1 noise whitening filters (that is, one whitening filter 704 per detector branch). Thus, the characteristics of the noise whitening filters 704 enter both the forward and the backward recursions on the detector trellis. The prediction noise variance σp2(a) refers to the noise as seen at the output of each whitening filter 704, and the branch metric mk(Sk−1, Sk) may be calculated as follows:




  
    
      m
      k
    
    ⁡
    
      (
      
        
          S
          
            k
            -
            1
          
        
        ,
        
          S
          k
        
      
      )
    
  
  =
  
    
      
        -
        
          1
          2
        
      
      ⁢
      ln
      ⁢
      
        {
        
          
            σ
            p
            2
          
          ⁡
          
            (
            
              a
              _
            
            )
          
        
        }
      
      ⁢
      
        
          
            {
            
              
                
                  z
                  k
                
                ⁡
                
                  (
                  
                    a
                    _
                  
                  )
                
              
              -
              
                
                  w
                  k
                
                ⁡
                
                  (
                  
                    a
                    _
                  
                  )
                
              
            
            }
          
          2
        
        
          2
          ⁢
          
            
          
          ⁢
          
            
              σ
              p
              2
            
            ⁡
            
              (
              
                a
                _
              
              )
            
          
        
      
    
    +
    
      ln
      ⁢
      
        
      
      ⁢
      
        P
        ⁡
        
          (
          
            a
            k
          
          )
        
      
    
  




where a is the data pattern corresponding to state transition Sk−1→Sk. In the branch metric equation, wk(a) is an ideal nominal signal associated with transition from state Sk−1 to state Sk, and zk(a) is the actual output of the noise whitening filter.

According to another embodiment, the soft noise-predictive DD-DMAX detector 902 may have normalization applied thereto. When the DMAX algorithm is normalized, the α (forward) and β (backward) variables may be represented with a predetermined finite number of bits as opposed to the values of these variables growing in magnitude without bound, as is possible using conventional DMAX algorithms. In addition, and advantageously, normalization does not affect LLR values. One normalization operation is shown below:




  
    
      α
      k
    
    ⁡
    
      (
      
        S
        k
      
      )
    
  
  =
  
    
      max
      
        S
        
          k
          -
          1
        
      
    
    ⁢
    
      
        {
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            1
          
          ,
          ...
          ⁢
          
            
          
          ,
          N
        
        )
      
    
  




Normalization: find




  
    
      A
      k
    
    =
    
      
        max
        
          S
          k
        
      
      ⁢
      
        {
        
          
            α
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        }
      
    
  
  ,
  
    

  
  ⁢
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
    
    →
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      -
      
        
          A
          k
        
        ⁢
        
          
        
        ⁢
        
          ∀
          
            
              α
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
      
    
  








  
    
      β
      
        k
        -
        1
      
    
    ⁡
    
      (
      
        S
        
          k
          -
          1
        
      
      )
    
  
  =
  
    
      max
      
        S
        k
      
    
    ⁢
    
      
        {
        
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            N
          
          ,
          ...
          ⁢
          
            
          
          ,
          2
        
        )
      
    
  




Normalization: find




  
    
      B
      
        k
        -
        1
      
    
    =
    
      
        max
        
          S
          
            k
            -
            1
          
        
      
      ⁢
      
        {
        
          
            β
            
              k
              -
              1
            
          
          ⁡
          
            (
            
              S
              
                k
                -
                1
              
            
            )
          
        
        }
      
    
  
  ,
  
    

  
  ⁢
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
    
    →
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      -
      
        
          B
          
            k
            -
            1
          
        
        ⁢
        
          ∀
          
            
              β
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
        
      
    
  




Of course, other algorithms for normalization may be possible as well, according to other embodiments.

In one embodiment, each noise whitening filter 704 in the noise whitening filter bank 906 may use a whitening function to minimize the variance of the noise affecting its output signal. In one approach, the whitening filter 704 may apply the following transfer polynomial to yk: W(D)=1−(p1D+ . . . +pλDλ), assuming that the tape channel 202 itself is characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLPL.
In another embodiment, the number of noise whitening filters 704 in the noise whitening filter bank 906 may equal the number of branches in the detector's trellis structure, e.g., a number of state transitions of the soft noise-predictive DD-DMAX detector 902. In another embodiment, the number of noise whitening filters 704 in the noise whitening filter bank 906 may depend on a longer bit pattern than the pattern defined by state transitions, i.e., there will be more noise whitening filters 704 than there are branches on the detector trellis.
Accordingly, the bits defining states Sk−1 and Sk will be insufficient to match on a one-to-one basis with a whitening filter; therefore, the missing bits may be taken from path memory associated with each state Sk−1. The branch metric mkak−1, Sk) for this calculation may be written as follows, in one approach:




  
    
      m
      k
    
    ⁡
    
      (
      
        
          S
          
            k
            -
            1
          
        
        ,
        
          S
          k
        
      
      )
    
  
  =
  
    
      
        -
        
          1
          2
        
      
      ⁢
      ln
      ⁢
      
        {
        
          
            σ
            p
            2
          
          ⁡
          
            [
            
              
                a
                _
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
            ]
          
        
        }
      
    
    -
    
      
        
          (
          
            
              
                z
                k
              
              ⁡
              
                [
                
                  
                    a
                    _
                  
                  ⁡
                  
                    (
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    )
                  
                
                ]
              
            
            -
            
              
                w
                k
              
              ⁡
              
                [
                
                  
                    a
                    _
                  
                  ⁡
                  
                    (
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    )
                  
                
                ]
              
            
          
          )
        
        2
      
      
        2
        ⁢
        
          
            σ
            p
            2
          
          ⁡
          
            [
            
              
                a
                _
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
            ]
          
        
      
    
    +
    
      ln
      ⁢
      
        
      
      ⁢
      
        P
        ⁡
        
          (
          
            a
            k
          
          )
        
      
    
  




where the notation a(Sk−1) indicates that the bit pattern a that defines a specific whitening filter also depends on the path memory associated with the previous state Sk−1, and where

In yet another embodiment, each noise whitening filter 704 in the noise whitening filter bank 906 may depend on a shorter bit pattern than the pattern defined by state transitions, i.e., there will be less noise whitening filters 704 than branches of the detector trellis; therefore, the same noise whitening filter 704 may be used more than once in the detector trellis.
For example, if in an 8-state detector trellis a is selected as a=(ak, ak−1, ak−2), then the two distinct branches shown below may use the same noise whitening filter 704.

Sk:(ak−1,ak−2,ak−3=0)→Sk+1:(ak,ak−1,ak−2)

Sk:(ak−1,ak−2,ak−3=1)→Sk+1:(ak,ak−1,ak−2)

In another embodiment, reduced state detection may be performed on any of the longer, shorter, or equal bit pattern schemes described previously. In reduced state detection, the whitening filter 704 may extend over a longer time span (i.e., a longer memory), but the soft detector 904 may use the same amount of states as before. As previously indicated, the soft detector 904 may have 2L+λ states. It is possible to use a longer whitening filter 704 and still keep 2L+λ states in the detector trellis using reduced-state detection. In this case, the bits defining states Sk−1 and Sk are not enough to specify the bit string of length L+λ+1 needed to compute the system output zk. In this case, the noise whitening filters may apply the following transfer polynomial: W(D)=1−(pi,1D+ . . . +pi,λ′Dλ′), where pi,1 . . . pi,λ′ are noise whitening coefficients, i is 0 to M−1 where M is a total number of noise whitening filters in the bank of noise whitening filters, the tape channel May be characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLDL, with 2L being a number of states of the tape channel, wherein the soft detector has a total of 2L+λ states, and the noise whitening filter ideally (without state reduction) leading to 2λ′ states, with λ′ being greater than λ.
Therefore, the missing bit(s) are taken from the path memory associated with each state Sk−1. The branch metric mk(Sk−1, Sk) may then be written as follows:




  
    
      m
      k
    
    ⁡
    
      (
      
        
          S
          
            k
            -
            1
          
        
        ,
        
          S
          k
        
      
      )
    
  
  =
  
    
      
        -
        
          1
          2
        
      
      ⁢
      ln
      ⁢
      
        {
        
          
            σ
            p
            2
          
          ⁡
          
            [
            
              
                a
                _
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
            ]
          
        
        }
      
    
    -
    
      
        
          (
          
            
              
                z
                k
              
              ⁡
              
                [
                
                  
                    a
                    _
                  
                  ⁡
                  
                    (
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    )
                  
                
                ]
              
            
            -
            
              
                w
                k
              
              ⁡
              
                [
                
                  
                    a
                    _
                  
                  ⁡
                  
                    (
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    )
                  
                
                ]
              
            
          
          )
        
        2
      
      
        2
        ⁢
        
          
            σ
            p
            2
          
          ⁡
          
            [
            
              
                a
                _
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
            ]
          
        
      
    
    +
    
      ln
      ⁢
      
        
      
      ⁢
      
        P
        ⁡
        
          (
          
            a
            k
          
          )
        
      
    
  




where the notation wk[a(Sk−1)] indicates that the bit pattern that defines wk, which is an ideal nominal signal associated with transition from state Sk−1 to state Sk, also depends on the path memory associated with the previous state Sk−1, and where σp2[a(Sk−1)] is data-pattern and previous-state dependent prediction noise variance.

In another embodiment, the whitening filter coefficients pi,1, pi,2, . . . , pi,λ may be estimated adaptively as shown in FIG. 10, a simplified version of which is described in U.S. patent application Ser. No. 12/753,586, which is herein incorporated by reference. Referring again to FIG. 10, the whitening filter coefficients pi, 1, pi,2, . . . pi,λ may be updated using a whitening filter coefficient updater 802 from soft information as follows (in FIG. 10, λ=2 is assumed for illustration purposes):

pi,1←pi,1+αei,k{circumflex over (n)}k−1 

pi,2←pi,2+αei,k{circumflex over (n)}k−2 

where α is the adaptation stepsize, ei,k is the error signal based on the address i (in this example, 64 whitening filters 704 are assumed, but any number may be used), and {circumflex over (n)}k−1, {circumflex over (n)}k−2 are the noise estimates from previous time instants, e.g., previous noise estimates. In addition, the whitening filter transfer polynomial may be defined as follows:

Wi(D)=1−(pi,1D+pi,2D2), i=0, . . . ,63

where i=0, . . . , 63 based on 64 whitening filters 704 in the bank of whitening filters 906.

Furthermore, the error signal ei,k may be input to a prediction noise variance computation 804 where prediction noise variance σp2 is computed based on the error signal ei,k, and a small number ε (e.g., 0.001). In the embodiment shown in FIG. 10, the prediction noise variance a σp2(i) that is used to calculate the next prediction noise variance σp2 is input from the bank of variance values 1002. The number of variance values in the bank of variance values 1002 may number the same as the number of whitening filters 704 in the bank of whitening filters 906, according to one embodiment.
In some instances, the tape may be written by a drive having a precoder positioned before the C1 encoder, e.g., an LDPC encoder and no precoder positioned after the encoder and/or immediately adjacent the write channel. In such case, the detector functions as noted elsewhere herein. However, if the tape was written by a drive with a precoder positioned after the C1 encoder and/or immediately adjacent the write channel, then the system may automatically compensate during signal detection for the effect on the data caused by the precoder in such position in the writing device. In either case, the data may have a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium.
The drive performing data readback may determine if and how the data has been precoded in any of the manners described above and below in a manner known in the art, such as detecting such information from the tape itself, cartridge memory, etc.
Referring now to FIG. 11, there is shown a representation of a tape drive system 1100 which uses, in a reading section, a soft detector 1102 that provides automatic compensation for the presence of precoding in the tape channel 1104. As shown, in the precoded tape channel 1104, a precoder 1106 is positioned after a C1 encoder 1108 and immediately prior to a tape channel 202, such that the output of the C1 encoder 1108 is sent to the precoder 1106, which, in turn, sends the precoder output to the tape channel 202 for writing on the tape. The tape channel 202 is shown as a single module representing respective components of the read and the write section, as would be understood by one skilled in the art.
The data which passes through the precoder 1106 may be described as having a characteristic of being passed through a precoder, such that the data may be handled differently and/or compensated for in a detector which reads a tape which has precoded data recorded thereon.
One embodiment of the precoded tape channel 1104 is shown in FIG. 12. As shown, the algorithms provided by the precoder 1106 and the tape channel 202 may be combined, as represented by the precoded tape channel 1104. Referring now to FIGS. 11-12, bits of data, bk, are sent to the precoder 1106. The precoder 1106 may apply the following equation to bk: 1/(1⊕D) where D is delay corresponding to a bit duration.
After the output, ak, of the precoder 1106 is read from the tape via the tape channel 202, the noiseless signal may be represented, for example, as an extended partial-response class 4 (EPR4) signal xk=ak+ak−1−ak−2−ak−3. The soft detector 1102 provides automatic compensation for the presence or absence of a precoder 1106 adjacent the write channel in the writing device by accounting for the precoding function that the precoder 1106 applies to the data before it is written to the tape and clearly also for the transformation that the tape channel 202 applies to the data as it is read from the tape.
For example, in one embodiment, the soft detector 1102 providing automatic compensation for the presence of a precoded tape channel 1104 may calculate the LLR as follows:




  
    LLR
    ⁡
    
      (
      
        b
        k
      
      )
    
  
  =
  
    
      
        max
        
          β
          1
        
      
      ⁢
      
        {
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              m
              
                k
                ⁢
                
                  
                
              
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
          +
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
        }
      
    
    -
    
      
        max
        
          β
          0
        
      
      ⁢
      
        {
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
          +
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
        }
      
    
  




where β0 is the set of all branches in the detector trellis corresponding to the state transitions Sk−1→Sk having label bk=0, and β1 is the set of all branches in detector trellis corresponding to the state transitions Sk−1→Sk having label bk=1. The branch metric mk(Sk−1, Sk) may then be written as follows:

mk(Sk−1,Sk)=−(yk−xk)2/(2σ−2)+ln P(bk)

where the a priori probabilities P(bk) provided by the soft C1 decoder 404 correspond to the appropriate bk-labeled branch being considered (i.e., bk=0 or bk=1).

In one approach, the soft detector 1102 providing automatic compensation for the presence of a precoded tape channel 1104 may be a noise predictive soft DMAX detector with a noise whitening filter. In another approach, the soft detector 1102 providing automatic compensation for the presence of a precoded tape channel 1104 may be a soft noise-predictive DD-DMAX detector with one or more noise whitening filters. In addition, any of these embodiments may be used in a reduced state detector, as described in more detail herein.
In accordance with one embodiment, the soft detector 1102 providing automatic compensation for the presence of a precoded tape channel 1104 may retain the same number of states and state transitions (e.g., branches) as in the case where precoding is not used. Additionally, the soft detector 1102 providing automatic compensation for the presence of a precoded tape channel 1104 may retain the same branch labeling with nominal output signal xk as in the case where precoding is not used.
Referring now to FIG. 13, another representation of a tape drive system 1300 is shown using, in a reading section, a soft detector 1302, which provides automatic compensation for a precoded tape channel 1304. Such soft detector 1302 and decoder 404 may be configured the same as the soft detector 1102 and decoder 404 in FIG. 11. As shown in FIG. 13, however, a first precoder 1306 is positioned before a C1 encoder 1108, such that the output of the first precoder 1306 is sent to the C1 encoder 1108. In addition, a second precoder 1308 is positioned after the C1 encoder 1108 and immediately prior to a tape channel 202 in the precoded tape channel 1304, such that the output of the C1 encoder 1108 is sent to the second precoder 1308, which, in turn, sends the second precoder output to the tape channel 202. Again, the tape channel 202 is shown as a single module representing respective components of the read and the write section, as would be understood by one skilled in the art.
The data which passes through the precoders 1306, 1308 may be described as having a characteristic of being passed through at least one precoder, such that the data may be handled differently and/or compensated for in a detector which reads a tape which has precoded data recorded thereon.
One embodiment of the precoded tape channel 1304 is shown in FIG. 14. As shown, the algorithms provided by the second precoder 1308 and the tape channel 202 may be combined, as represented by the precoded tape channel 1304. Now referring to FIGS. 13-14, bits of data, bk, are sent to the second precoder 1308. In one embodiment, the precoder 1308 may apply the following equation to bk: 1/(1⊕D) where D is delay corresponding to bit duration. The output, ak, of the precoder 1308 is then read from the tape via the tape channel 202 to generate noiseless signal xk, which in this example is represented as an EPR4 signal xk=ak+ak−1−ak−2−ak−3. The soft detector 1302 provides automatic compensation for the presence or absence of a second precoder 1308 adjacent the write channel in the writing device by accounting for the algorithm that the second precoder 1308 applies to the data before it is written to the tape and for the transformation that the tape channel 202 applies to the data as it is read from the tape.
In one embodiment, the first precoder 1306 may apply the following equation to its input: 1/(1⊕D) where D is repetitive delay.
Furthermore, in one embodiment the soft detector 1302 providing automatic compensation for the presence of a precoded tape channel 1304 may be a noise predictive soft DMAX detector with a noise whitening filter. In another approach, the soft detector 1302 providing automatic compensation for the presence of a precoded tape channel 1304 may be a soft noise-predictive DD-DMAX detector with one or more noise whitening filters. In addition, any of these embodiments may be used in a reduced state detector, as described in more detail herein.
In accordance with one embodiment, the soft detector 1302 providing automatic compensation for the presence of a precoded tape channel 1304 may retain the same number of states and state transitions (e.g., branches) as in the case where precoding is not used. Additionally, the soft detector 1302 providing automatic compensation for the presence of a precoded tape channel 1304 may retain the same branch labeling with nominal output signal xk as in the case where precoding is not used.
As the above examples describe, the soft detector is capable of providing automatic compensation for precoded data by selecting a particular algorithm based on whether or not the precoded data was written to the magnetic tape medium by a device having a precoder positioned immediately adjacent a write channel.
However, is some cases, it is possible to use the same algorithm, such as a DMAX algorithm, on precoded and non-precoded data. In these cases, the soft detector is capable of providing automatic compensation for the precoded data by interpreting state transition calculations (detector trellis branches) based on a type of precoding used in a precoder positioned immediately adjacent a write channel. In these cases, it is possible for the soft detector to use a same number of states (memory) whether data was written to the magnetic tape medium via a precoder positioned immediately adjacent a write channel or not (e.g., the data was written to the magnetic tape medium without a precoder).
Referring now to FIG. 15, examples of specific precoding cases are shown, according to several embodiments. In trellis structure 1502 on the left side of FIG. 15, the trellis structure is shown for a case where no precoding is used, i.e., bk≡ak. As can be seen, the trellis structure 1502 shows dashed lines for branches where bk≡ak is 0, and solid lines for branches where bk≡ak is 1. For this example, an 8-state detector would be used, as the detector has memory for ak−1, ak−2, and ak−3 in order to calculate ak.
Referring now to trellis structure 1504, in an example using 1/(1⊕D) precoding, it can be seen that the same state transitions (Sk−1→Sk) occur (branches) as in the non-precoding case, but some of these state transitions are interpreted differently from the non-precoding example shown as trellis structure 1502. For example, in trellis structure 1504, the branch from 110 to 111 now represents bk=0, instead of ak=1 as in trellis structure 1502.
Similarly, referring to trellis structure 1506, in an example using 1/(1⊕D2) precoding, it can be seen that the same state transitions (Sk−1→Sk) occur (branches) as in the non-precoding case, but some of these state transitions are interpreted differently from the non-precoding example shown as trellis structure 1502. For example, in trellis structure 1506, the branch from 010 to 001 now represents bk=1, instead of ak=0 as in trellis structure 1502.
It should be noted that the exact same branches occur for each of the precoded and non-precoded trellis structures. In addition, it should be noted that the same number of states may be used in the detector for calculating bit estimations regardless of whether the data is precoded or not.
Also, the types of precoding and/or algorithms used in the examples described herein are not meant to be limiting on what types of precoding and/or algorithms may be used in combination with other embodiments and/or approaches described herein. Any type of precoding and/or algorithm known in the art may be used. In addition, the tape channel examples used herein, EPR4, is not meant to be limiting on what type of tape channel transfer function may be used in conjunction with any embodiments and/or approaches described herein. Any tape channel transfer function known in the art may be used. Furthermore, the whitening filter transfer polynomial examples used herein, are not meant to be limiting on what type of whitening filter transfer function may be used in conjunction with any embodiments and/or approaches described herein. Ally whitening filter transfer function known in the art may be used.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
While various embodiments have been described above, it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of an embodiment of the present invention should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents.

## Claims

1. A data storage system, comprising:
a tape channel for reading precoded data from a magnetic tape medium to produce a signal;
a noise whitening filter positioned subsequent to the tape channel and configured to pass the signal to a soft detector, wherein the noise whitening filter is configured to control variance of noise affecting the signal output from the filter, wherein the noise whitening filter processes the signal according to the following transfer polynomial: W(D)=1−(p1D+ . . . +pλDλ), where p1 . . . Pλ are the noise whitening coefficients with the noise whitening filter having 2λ states, and where the tape channel is characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLDL where D is delay corresponding to bit duration, with the tape channel having 2L states, L represents a memory length of the tape channel, and λ represents a memory length of the noise whitening filter;
the soft detector configured to calculate first soft information about each bit of the signal and sending the first soft information to a soft decoder; and
the soft decoder positioned subsequent to the soft detector, the soft decoder being configured to calculate second soft information about each bit of the signal and sending the second soft information to the soft detector,
wherein the precoded data comprises a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium, and
wherein the soft detector provides automatic compensation for the precoded data.

2. The data storage system as recited in claim 1, wherein the soft detector provides automatic compensation for the precoded data by selecting a particular algorithm based on whether or not the precoded data was written to the magnetic tape medium by a device having a precoder positioned immediately adjacent a write channel.

3. The data storage system as recited in claim 1, wherein the soft detector uses a same number of states whether data was written to the magnetic tape medium via a precoder positioned immediately adjacent a write channel or whether data was written to the magnetic tape medium without a precoder.

4. The data storage system as recited in claim 1, wherein the soft detector provides automatic compensation for the precoded data by interpreting state transition calculations based on a type of precoding used in a precoder positioned immediately adjacent a write channel.

5. The data storage system as recited in claim 1, wherein the whitening filter coefficients p1, p2, . . . , pλ are estimated adaptively.

6. The data storage system as recited in claim 1, wherein the soft detector applies a Dual-Max (DMAX) algorithm comprising:



  
    
      
    
    ⁢
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      ≅
      
        
          max
          
            S
            
              k
              -
              1
            
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                α
                
                  k
                  -
                  1
                
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
          
          }
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      ≅
      
        
          max
          
            S
            k
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                β
                k
              
              ⁡
              
                (
                
                  S
                  k
                
                )
              
            
          
          }
        
      
    
  




  
    
      
        LLR
        ⁡
        
          (
          
            α
            k
          
          )
        
      
      ≅
      
        
          
            max
            
              
                
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    →
                    
                      S
                      k
                    
                  
                
              
              
                
                  
                    
                      α
                      k
                    
                    =
                    
                      +
                      1
                    
                  
                
              
            
          
          ⁢
          
            {
            
              
                
                  α
                  
                    k
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
              +
              
                
                  γ
                  
                    k
                    ⁢
                    
                      
                    
                  
                
                ⁡
                
                  (
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    ,
                    
                      S
                      k
                    
                  
                  )
                
              
              +
              
                
                  β
                  k
                
                ⁡
                
                  (
                  
                    S
                    k
                  
                  )
                
              
            
            }
          
        
        -
        
          
            max
            
              
                
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    →
                    
                      S
                      k
                    
                  
                
              
              
                
                  
                    
                      α
                      k
                    
                    =
                    
                      -
                      1
                    
                  
                
              
            
          
          ⁢
          
            {
            
              
                
                  α
                  
                    k
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
              +
              
                
                  γ
                  k
                
                ⁡
                
                  (
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    ,
                    
                      S
                      k
                    
                  
                  )
                
              
              +
              
                
                  β
                  k
                
                ⁡
                
                  (
                  
                    S
                    k
                  
                  )
                
              
            
            }
          
        
      
    
    ,
  



wherein yk is the signal, ak denotes a bit in a bit sequence of the signal, ak(Sk) is an alpha term for a current state (Sk) in a forward recursion, ak(Sk−1) is an alpha term for a previous state (Sk−1) in the forward recursion βk(Sk) is a beta term for the current state in a backward recursion, βk−1(Sk−1) is a beta term for the previous state in the backward recursion, and LLR(ak) is an approximation of a log-likelihood term that calculates a posteriori probabilities.

7. The data storage system as recited in claim 6, wherein the characteristic of the precoded data is consistent with a precoder that applies either 1/(1⊕D) or 1/(1⊕D2) to bits of data bk, where D is delay corresponding to bit duration.

8. The data storage system as recited in claim 7, wherein the DMAX algorithm computes a branch metric, mk(Sk−1, Sk), of a transition to a current state (Sk) from a previous state (Sk−1) represented by: mk(Sk−1,Sk)−−(yk−xk)2/(2σ2)+ln P(bk), where σ2 is prediction noise variance, P(bk) are a priori probabilities provided by the soft decoder, yk is an input sample, and xk is an ideal nominal output signal from the tape channel.

9. The data storage system as recited in claim 8, wherein the DMAX algorithm is normalized according to the following relationship:




  
    
      α
      k
    
    ⁡
    
      (
      
        S
        k
      
      )
    
  
  =
  
    
      max
      
        S
        
          k
          -
          1
        
      
    
    ⁢
    
      
        {
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            1
          
          ,
          ...
          ⁢
          
            
          
          ,
          N
        
        )
      
    
  



Normalization: find





  
    
      A
      k
    
    =
    
      
        max
        
          S
          k
        
      
      ⁢
      
        {
        
          
            α
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        }
      
    
  
  ,
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
    
    →
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      -
      
        
          A
          k
        
        ⁢
        
          ∀
          
            
              α
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
      
    
  








  
    
      β
      
        k
        -
        1
      
    
    ⁡
    
      (
      
        S
        
          k
          -
          1
        
      
      )
    
  
  =
  
    
      max
      
        S
        k
      
    
    ⁢
    
      
        {
        
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            N
          
          ,
          ...
          ⁢
          
            
          
          ,
          2
        
        )
      
    
  



Normalization: find





  
    
      B
      
        k
        -
        1
      
    
    =
    
      
        max
        
          S
          
            k
            -
            1
          
        
      
      ⁢
      
        {
        
          
            β
            
              k
              -
              1
            
          
          ⁡
          
            (
            
              S
              
                k
                -
                1
              
            
            )
          
        
        }
      
    
  
  ,
  
    

  
  ⁢
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
    
    →
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      -
      
        
          B
          
            k
            -
            1
          
        
        ⁢
        
          ∀
          
            
              β
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
        
      
    
  
  ,




wherein Ak denotes a maximum value for ak across all states (Sk), and wherein ak for each state (Sk) is replaced with a value equaling ak minus Ak for normalization, and wherein Bk−1 denotes a maximum value for βk−1 across all previous states (Sk−1), and wherein βk for each previous state (Sk−1) is replaced with a value equaling βk−1 minus Bk−1 for normalization.

10. A method, comprising:
reading precoded data from a magnetic tape medium to produce a signal;
passing the signal through a soft detector to calculate first soft information about each bit of the signal and to provide adaptive compensation for the precoded data;
sending the first soft information to a soft decoder;
passing the signal through the soft decoder to calculate second soft information about each bit of the signal; and
sending the second soft information to the soft detector,
wherein the precoded data comprises a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium,
wherein the characteristic of the precoded data is consistent with a precoder that applies 1/(1⊕D2) to bits of data bk, where D is delay corresponding to bit duration.

11. The method as recited in claim 10, wherein the soft detector provides automatic compensation for the precoded data by selecting a particular algorithm based on whether or not the precoded data was written to the magnetic tape medium by a device having a precoder positioned immediately adjacent a write channel.

12. The method as recited in claim 10, wherein the soft detector uses a same number of states whether data was written to the magnetic tape medium via a precoder positioned immediately adjacent a write channel or whether data was written to the magnetic tape medium without a precoder.

13. The method as recited in claim 10, wherein the soft detector provides automatic compensation for the preceded data by interpreting state transition calculations based on a type of precoding used in a precoder positioned immediately adjacent a write channel.

14. The method as recited in claim 10, further comprising passing the signal through a noise whitening filter to control variance of the signal, wherein the noise whitening filter is positioned subsequent to a tape channel and configured to pass the signal to the soft detector, wherein the noise whitening filter is configured to control variance of the signal, wherein the noise whitening filter processes the signal according to the following transfer polynomial: W(D)=1−(p1D+ . . . +pλDλ), where p1 . . . pλ are the noise whitening coefficients with the noise whitening filter having 2λ states, and where the tape channel is characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLDL where D is delay corresponding to bit duration, with the tape channel having 2L states, L represents a memory length of the tape channel, and λ represents a memory length of the noise whitening filter.

15. The method as recited in claim 10, wherein the soft detector applies a Dual-Max (DMAX) algorithm comprising:



  
    
      
    
    ⁢
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      ≅
      
        
          max
          
            S
            
              k
              -
              1
            
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                α
                
                  k
                  -
                  1
                
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
          
          }
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      ≅
      
        
          max
          
            S
            k
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                β
                k
              
              ⁡
              
                (
                
                  S
                  k
                
                )
              
            
          
          }
        
      
    
  




  
    
      
        LLR
        ⁡
        
          (
          
            α
            k
          
          )
        
      
      ≅
      
        
          
            max
            
              
                
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    →
                    
                      S
                      k
                    
                  
                
              
              
                
                  
                    
                      α
                      k
                    
                    =
                    
                      +
                      1
                    
                  
                
              
            
          
          ⁢
          
            {
            
              
                
                  α
                  
                    k
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
              +
              
                
                  γ
                  
                    k
                    ⁢
                    
                      
                    
                  
                
                ⁡
                
                  (
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    ,
                    
                      S
                      k
                    
                  
                  )
                
              
              +
              
                
                  β
                  k
                
                ⁡
                
                  (
                  
                    S
                    k
                  
                  )
                
              
            
            }
          
        
        -
        
          
            max
            
              
                
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    →
                    
                      S
                      k
                    
                  
                
              
              
                
                  
                    
                      α
                      k
                    
                    =
                    
                      -
                      1
                    
                  
                
              
            
          
          ⁢
          
            {
            
              
                
                  α
                  
                    k
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
              +
              
                
                  γ
                  k
                
                ⁡
                
                  (
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    ,
                    
                      S
                      k
                    
                  
                  )
                
              
              +
              
                
                  β
                  k
                
                ⁡
                
                  (
                  
                    S
                    k
                  
                  )
                
              
            
            }
          
        
      
    
    ,
  



wherein yk is the signal, ak denotes a bit in a bit sequence of the signal, ak(Sk) is an alpha term for a current state (Sk) in a forward recursion, ak(Sk−1) is an alpha term for a previous state (Sk−1) in the forward recursion βk(Sk) is a beta term for the current state in a backward recursion, βk−1(Sk−1) is a beta term for the previous state in the backward recursion, and LLR(ak) is an approximation of a log-likelihood term that calculates a posteriori probabilities.

16. The method as recited in claim 14, wherein the whitening filter coefficients p1, p2, . . . , pλ are estimated adaptively.

17. The method as recited in claim 15, wherein the DMAX algorithm computes a branch metric, mk(Sk−1, Sk), of a transition to a current state (Sk) from a previous state (Sk−1) represented by:
mk(Sk−1, Sk)=−(yk−xk)2/(2σ2)+ln P(bk), where σ2 is prediction noise variance, P(bk) are a priori probabilities provided by the soft decoder, yk is an input sample, and xk is an ideal nominal output from the tape channel.

18. The method as recited in claim 17, wherein the DMAX algorithm is normalized according to the following relationship:




  
    
      α
      k
    
    ⁡
    
      (
      
        S
        k
      
      )
    
  
  =
  
    
      max
      
        S
        
          k
          -
          1
        
      
    
    ⁢
    
      
        {
        
          
            
              α
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            1
          
          ,
          ...
          ⁢
          
            
          
          ,
          N
        
        )
      
    
  



Normalization: find





  
    
      A
      k
    
    =
    
      
        max
        
          S
          k
        
      
      ⁢
      
        {
        
          
            α
            k
          
          ⁡
          
            (
            
              S
              k
            
            )
          
        
        }
      
    
  
  ,
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
    
    →
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      -
      
        
          A
          k
        
        ⁢
        
          ∀
          
            
              α
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
        
      
    
  








  
    
      β
      
        k
        -
        1
      
    
    ⁡
    
      (
      
        S
        
          k
          -
          1
        
      
      )
    
  
  =
  
    
      max
      
        S
        k
      
    
    ⁢
    
      
        {
        
          
            
              β
              k
            
            ⁡
            
              (
              
                S
                k
              
              )
            
          
          +
          
            
              m
              k
            
            ⁡
            
              (
              
                
                  S
                  
                    k
                    -
                    1
                  
                
                ,
                
                  S
                  k
                
              
              )
            
          
        
        }
      
      ⁢
      
        
      
      ⁢
      
        (
        
          
            k
            =
            N
          
          ,
          ...
          ⁢
          
            
          
          ,
          2
        
        )
      
    
  



Normalization: find





  
    
      B
      
        k
        -
        1
      
    
    =
    
      
        max
        
          S
          
            k
            -
            1
          
        
      
      ⁢
      
        {
        
          
            β
            
              k
              -
              1
            
          
          ⁡
          
            (
            
              S
              
                k
                -
                1
              
            
            )
          
        
        }
      
    
  
  ,
  
    

  
  ⁢
  
    
      replace
      ⁢
      
        
      
      ⁢
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
    
    →
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      -
      
        
          B
          
            k
            -
            1
          
        
        ⁢
        
          ∀
          
            
              β
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                S
                
                  k
                  -
                  1
                
              
              )
            
          
        
      
    
  
  ,




wherein Ak denotes a maximum value for ak across all states (Sk), and wherein ak for each state (Sk) is replaced with a value equaling ak minus Ak for normalization, and wherein Bk−1 denotes a maximum value for βk−1 across all previous states (Sk−1), and wherein βk for each previous state (Sk−1) is replaced with a value equaling βk−1 minus Bk−1 for normalization.

19. A computer program product, comprising a non-transitory computer readable storage medium having computer readable program code embodied therewith, the computer readable program code comprising:
computer readable program code configured to read precoded data from a magnetic tape medium to produce a signal;
computer readable program code configured to pass the signal through a soft detector to calculate first soft information about each bit of the signal and to provide adaptive compensation for the precoded data;
computer readable program code configured to send the first soft information to a soft decoder;
computer readable program code configured to pass the signal through the soft decoder to calculate second soft information about each bit of the signal; and
computer readable program code configured to send the second soft information to the soft detector,
wherein the precoded data comprises a characteristic of being passed through at least one precoder prior to being written to the magnetic tape medium, and
wherein the soft detector applies a Dual-Max (DMAX) algorithm comprising:




  
    
      
    
    ⁢
    
      
        
          α
          k
        
        ⁡
        
          (
          
            S
            k
          
          )
        
      
      ≅
      
        
          max
          
            S
            
              k
              -
              1
            
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                α
                
                  k
                  -
                  1
                
              
              ⁡
              
                (
                
                  S
                  
                    k
                    -
                    1
                  
                
                )
              
            
          
          }
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          β
          
            k
            -
            1
          
        
        ⁡
        
          (
          
            S
            
              k
              -
              1
            
          
          )
        
      
      ≅
      
        
          max
          
            S
            k
          
        
        ⁢
        
          {
          
            
              
                γ
                k
              
              ⁡
              
                (
                
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  ,
                  
                    S
                    k
                  
                
                )
              
            
            +
            
              
                β
                k
              
              ⁡
              
                (
                
                  S
                  k
                
                )
              
            
          
          }
        
      
    
  




  
    
      
        LLR
        ⁡
        
          (
          
            α
            k
          
          )
        
      
      ≅
      
        
          
            max
            
              
                
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    →
                    
                      S
                      k
                    
                  
                
              
              
                
                  
                    
                      α
                      k
                    
                    =
                    
                      +
                      1
                    
                  
                
              
            
          
          ⁢
          
            {
            
              
                
                  α
                  
                    k
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
              +
              
                
                  γ
                  
                    k
                    ⁢
                    
                      
                    
                  
                
                ⁡
                
                  (
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    ,
                    
                      S
                      k
                    
                  
                  )
                
              
              +
              
                
                  β
                  k
                
                ⁡
                
                  (
                  
                    S
                    k
                  
                  )
                
              
            
            }
          
        
        -
        
          
            max
            
              
                
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    →
                    
                      S
                      k
                    
                  
                
              
              
                
                  
                    
                      α
                      k
                    
                    =
                    
                      -
                      1
                    
                  
                
              
            
          
          ⁢
          
            {
            
              
                
                  α
                  
                    k
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    S
                    
                      k
                      -
                      1
                    
                  
                  )
                
              
              +
              
                
                  γ
                  k
                
                ⁡
                
                  (
                  
                    
                      S
                      
                        k
                        -
                        1
                      
                    
                    ,
                    
                      S
                      k
                    
                  
                  )
                
              
              +
              
                
                  β
                  k
                
                ⁡
                
                  (
                  
                    S
                    k
                  
                  )
                
              
            
            }
          
        
      
    
    ,
  


wherein yk is the signal, ak denotes a bit in a bit sequence of the signal, ak(Sk) is an alpha term for a current state (Sk) in a forward recursion, ak(Sk−1) is an alpha term for a previous state (Sk−1) in the forward recursion βk(Sk) is a beta term for the current state in a backward recursion, βk−1(Sk−1) is a beta term for the previous state in the backward recursion, and LLR(ak) is an approximation of a log-likelihood term that calculates a posteriori probabilities.

20. The computer program product as recited in claim 19, further comprising computer readable program code configured to pass the signal through a noise whitening filter to minimize variance of the noise affecting the signal output from the filter, wherein the noise whitening filter is positioned subsequent to a tape channel and configured to pass the signal to the soft detector, wherein the noise whitening filter processes the signal according to the following transfer polynomial: W(D)=1−(p1D+ . . . +pλDλ), where p1 . . . pλ are noise whitening coefficients with the noise whitening filter having 2λ states, and where the tape channel is characterized by a transfer polynomial F(D)=1+f1D+ . . . +fLDL where D is delay corresponding to bit duration, with the tape channel having 2L states, L represents a memory length of the tape channel, and λ represents a memory length of the noise whitening filter.

21. The computer program product as recited in claim 19,
wherein the soft detector considers data dependent noise in calculating the first soft information about each bit of the signal.

22. The computer program product as recited in claim 19, wherein the characteristic of the precoded data is consistent with a precoder that applies either 1(1⊕D) or 1/(1⊕D2) to bits of data bk, where D is delay corresponding to bit duration.

23. The computer program product as recited in claim 22, wherein the DMAX algorithm computes a branch metric, mk(Sk−1, Sk), of a transition to a current state (Sk) from a previous state (Sk−1) represented by:
mk(Sk−1,Sk)=−(yk−xk)2/(2σ2)+ln P(bk), where σ2 is prediction noise variance, P(bk) are a priori probabilities provided by the soft decoder, yk is an input sample, and xk is an ideal nominal output from the tape channel.

24. The computer program product as recited in claim 19, wherein the soft detector uses a same number of states whether data was written to the magnetic tape medium via a precoder positioned immediately adjacent a write channel or whether data was written to the magnetic tape medium without a precoder.

25. The computer program product as recited in claim 19, wherein the soft detector provides automatic compensation for the precoded data by interpreting state transition calculations based on a type of precoding used in a precoder positioned immediately adjacent a write channel.