# Patent

## Title
Data storage device delaying seek operation to avoid thermal asperities

## Abstract

A data storage device is disclosed comprising a head actuated over a disk comprising a plurality of tracks, wherein at least two of the tracks comprise a thermal asperity. Prior to seeking the head from a first track to a second track, for each of at least two of the thermal asperities a minimum seek delay and a maximum seek delay that will cause the head to miss the thermal asperity are computed, and an allowed seek delay range that will cause the head to miss the thermal asperity is computed. When the undelayed seek will cause the head to hit at least one thermal asperity, the seek is delayed by a seek delay determined based on the minimum seek delays, the maximum seek delays, and the allowed seek delay ranges.

## Background
BACKGROUND
Data storage devices such as disk drives comprise a disk and a head connected to a distal end of an actuator arm which is rotated about a pivot by a voice coil motor (VCM) to position the head radially over the disk. The disk comprises a plurality of radially spaced, concentric tracks for recording user data sectors and servo sectors. The servo sectors comprise head positioning information (e.g., a track address) which is read by the head and processed by a servo control system to control the actuator arm as it seeks from track to track.
FIG. 1 shows a prior art disk format 2 as comprising a number of servo tracks 4 defined by servo sectors 60-6N recorded around the circumference of each servo track. Each servo sector 6i comprises a preamble 8 for storing a periodic pattern, which allows proper gain adjustment and timing synchronization of the read signal, and a sync mark 10 for storing a special pattern used to symbol synchronize to a servo data field 12. The servo data field 12 stores coarse head positioning information, such as a servo track address, used to position the head over a target data track during a seek operation. Each servo sector 6i further comprises groups of servo bursts 14 (e.g., N and Q servo bursts), which are recorded with a predetermined phase relative to one another and relative to the servo track centerlines. The phase based servo bursts 14 provide fine head position information used for centerline tracking while accessing a data track during write/read operations. A position error signal (PES) is generated by reading the servo bursts 14, wherein the PES represents a measured position of the head relative to a centerline of a target servo track. A servo controller processes the PES to generate a control signal applied to a head actuator (e.g., a voice coil motor) in order to actuate the head radially over the disk in a direction that reduces the PES.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 shows a prior art disk format comprising a plurality of servo tracks defined by servo sectors.
FIG. 2A shows a data storage device in the form of a disk drive according to an embodiment comprising a head actuated over a disk comprising a plurality of tracks, wherein at least two of the tracks comprise a thermal asperity.
FIG. 2B is a flow diagram according to an embodiment wherein a seek is delayed in order to avoid the thermal asperities during the seek.
FIGS. 3A and 3B illustrate cases where the head may hit a thermal asperity during a seek according to an embodiment.
FIGS. 4A and 4B illustrate cases where the head may avoid a thermal asperity during a seek according to an embodiment.



DETAILED DESCRIPTION
FIG. 2A shows a data storage device in the form of a disk drive according to an embodiment comprising a head 16 actuated over a disk 18 comprising a plurality of tracks 20, wherein at least two of the tracks 20 comprise a thermal asperity. The disk drive further comprises control circuitry 22 configured to execute the flow diagram of FIG. 2B, wherein prior to seeking the head from a first track to a second track (block 24), for each of at least two of the thermal asperities a minimum seek delay and a maximum seek delay that will cause the head to miss the thermal asperity are computed (block 26), and an allowed seek delay range that will cause the head to miss the thermal asperity is computed (block 28). When the undelayed seek will cause the head to hit at least one thermal asperity (block 30), the seek is delayed by a seek delay determined based on the minimum seek delays, the maximum seek delays, and the allowed seek delay ranges (block 32).
In the embodiment of FIG. 2A, servo sectors 340-34N define a plurality of servo tracks 20, wherein data tracks are defined relative to the servo tracks at the same or different radial density. In an embodiment where the servo sectors 340-34N are recorded at the same data rate, the servo sectors 340-34N form servo wedges that extend radially across the disk 18 as shown in FIG. 2A. Other embodiments may employ zoned servo sectors wherein the data rate may vary across the radius of the disk, thereby forming servo wedges within each servo zone. The control circuitry 22 processes a read signal 36 emanating from the head 16 to demodulate the servo sectors 340-34N and generate a position error signal (PES) representing an error between the actual position of the head and a target position relative to a target track. The control circuitry 22 filters the PES using a suitable compensation filter to generate a control signal 38 applied to a voice coil motor (VCM) 40 which rotates an actuator arm 42 about a pivot in order to actuate the head 16 radially over the disk 18 in a direction that reduces the PES. The servo sectors 340-34N may comprise any suitable head position information, such as a track address for coarse positioning and servo bursts for fine positioning. The servo bursts may comprise any suitable pattern, such as an amplitude based servo pattern or a phase based servo pattern.
In one embodiment, at least two of the tracks 20 comprise a thermal asperity which may comprise a raised area of the disk surface due to a defect in manufacturing the disk, a contaminant on the disk, or any other aberration that may cause an asperity on the disk surface. In one embodiment, it may be desirable to prevent the head 16 from hitting a thermal asperities since the collision may damage one or more elements of the head, or induce a disturbance in the servo control system, or cause any other undesirable effect. According, in one embodiment prior to seeking the head 16 across the disk surface from a first track to a second track based on a normally computed seek (i.e., an undelayed seek), the control circuitry 22 determines whether the undelayed seek will cause the head to hit at least one of the thermal asperities during the seek. If so, in one embodiment the control circuitry 22 computes a seek delay for the seek which will cause the head to miss at least one of the thermal asperities during the seek.
Assuming the head is at servo wedge w0 at the beginning of a seek operation, and assuming it will take time ti in servo wedges for the head to reach one of the tracks comprising a thermal asperity TAi, then the wedge number wi when the head reaches the track may be computed as:

wi=mod(ti+w0,Rev)

where Rev represents a total number of servo wedges in the track comprising the thermal asperity. Any suitable technique may be employed to compute the time ti in servo wedges that it will take the head to reach a servo track having thermal asperity TAi, wherein in one embodiment the time ti may be computed based on the seek profile employed for the seek, which in one embodiment may depend on the seek length. FIGS. 3A and 3B illustrate cases where the head will hit thermal asperity TAi if the above wedge number wi falls within a range of wedges impacted by the thermal asperity. FIG. 3A illustrates a case where the thermal asperity TAi occurs in the middle of a track, and FIG. 3B illustrates a case where the thermal asperity TAi wraps around from the end of the track (last servo wedge number) to the beginning of the track (first servo wedge number). FIGS. 4A and 4B illustrate cases where the head will miss thermal asperity TAi if the above wedge number wi falls outside the range of wedges impacted by the thermal asperity TAi.

In one embodiment, prior to executing a seek operation the control circuitry 22 computes the above wedge number wi for each servo track comprising a thermal asperity, and if the head will hit one or more of the thermal asperities (i.e., if the wedge number wi falls within the range of wedges impacted by each thermal asperity), then the control circuitry 22 computes a seek delay to delay the seek so that the head will miss the thermal asperities during the seek. In one embodiment, the control circuitry 22 computes the seek delay as a minimum seek delay that will cause the head to miss the thermal asperities during the seek.
In one embodiment, when an undelayed seek will cause the head to hit a thermal asperity, the control circuitry 22 computes a minimum seek delay and a maximum seek delay that will cause the head to miss the thermal asperity according to:




  {
  
     
    
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              <
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
    
  




where i represents an index for the thermal asperity, tmin,i represents the minimum seek delay, tmax,i represents the maximum seek delay, wi represents a servo wedge in the thermal asperity where the head will hit the thermal asperity during the undelayed seek, wi0 and wi1 represent servo wedges that define a boundary of the thermal asperity (e.g., FIGS. 3A and 3B), and Rev represents a total number of servo wedges in the track comprising the thermal asperity. In one embodiment, when the undelayed seek will cause the head to miss the thermal asperity, the control circuitry 22 is configured to compute an allowed seek delay range that will cause the head to miss the thermal asperity according to:





  {
  
     
    
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
                +
                1
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              <
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
            
          
        
      
      
        
          
            
              Rev
              +
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
              -
              
                w
                i
              
              +
              1
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
                +
                1
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
    
  




where i represents an index for the thermal asperity, and td represents the allowed seek delay range. In one embodiment, after computing the above minimum seek delay and maximum seek delay that will cause the head to miss each “hit” thermal asperity, and after computing the allowed seek delay that will cause the head to still avoid each “miss” thermal asperity, the control circuitry 22 is configured to compute the seek delay by:

    (1) for all cases where the head will hit the thermal asperities compute an acceptable delay range according to:

tmin=tmin,i+1, tmax=tmax,i−1

    (2) if tmin≦tminNot,i for all cases where the head will miss the thermal asperities then the seek delay is set equal to tmin, otherwise for each case where the head will miss the thermal asperities if tmin>tminNot,i then tmin=tmax Not,i.

In one embodiment, the above second step is executed for each “miss” case (after removing the current “miss” case from the list) until all of the “miss” cases have been processed. In one embodiment if the control circuitry 22 detects only “hit” cases, then the seek delay is set equal to the tmin initialized in the above first step (i.e., it is not necessary to execute the above second step). In one embodiment if during the above second step tmin>tminNot,i for a miss case and tmax<tmaxNot,i, then it is not possible to avoid the thermal asperity by delaying the seek based on the above algorithm, and therefore another suitable action may be taken such as raising the fly height of the head during at least part of the seek.



In one embodiment, the control circuitry 22 may execute a rotational position optimization (RPO) algorithm in which a plurality of access commands are stored in a command queue and then selected for execution based on an order that improves the performance of the disk drive. For example, the RPO algorithm may select the access commands based on an order that minimizes the execution time to complete the access commands, thereby maximizing the throughput of the disk drive. In one embodiment, the control circuitry 22 may compute the seek delay ranges for at least two access commands in the command queue that will cause the head to miss the thermal asperities as described above. The seek delay ranges for the access commands may then be taken into account in the RPO algorithm in addition to other access latency parameters, such as the seek delay and rotational delay required for each access command. In one embodiment, the RPO algorithm may select a non-minimum seek delay for one or more of the access commands when determining the execution order. That is, the optimal execution order as determined by the RPO algorithm may result in a non-minimum seek delay being assigned to one or more of the access commands in the command queue.
Any suitable control circuitry may be employed to implement the flow diagrams in the above embodiments, such as any suitable integrated circuit or circuits. For example, the control circuitry may be implemented within a read channel integrated circuit, or in a component separate from the read channel, such as a disk controller, or certain operations described above may be performed by a read channel and others by a disk controller. In one embodiment, the read channel and disk controller are implemented as separate integrated circuits, and in an alternative embodiment they are fabricated into a single integrated circuit or system on a chip (SOC). In addition, the control circuitry may include a suitable preamp circuit implemented as a separate integrated circuit, integrated into the read channel or disk controller circuit, or integrated into a SOC.
In one embodiment, the control circuitry comprises a microprocessor executing instructions, the instructions being operable to cause the microprocessor to perform the flow diagrams described herein. The instructions may be stored in any computer-readable medium. In one embodiment, they may be stored on a non-volatile semiconductor memory external to the microprocessor, or integrated with the microprocessor in a SOC. In another embodiment, the instructions are stored on the disk and read into a volatile semiconductor memory when the disk drive is powered on. In yet another embodiment, the control circuitry comprises suitable logic circuitry, such as state machine circuitry.
In various embodiments, a disk drive may include a magnetic disk drive, an optical disk drive, etc. In addition, while the above examples concern a disk drive, the various embodiments are not limited to a disk drive and can be applied to other data storage devices and systems, such as magnetic tape drives, solid state drives, hybrid drives, etc. In addition, some embodiments may include electronic devices such as computing devices, data server devices, media content storage devices, etc. that comprise the storage media and/or control circuitry as described above.
The various features and processes described above may be used independently of one another, or may be combined in various ways. All possible combinations and subcombinations are intended to fall within the scope of this disclosure. In addition, certain method, event or process blocks may be omitted in some implementations. The methods and processes described herein are also not limited to any particular sequence, and the blocks or states relating thereto can be performed in other sequences that are appropriate. For example, described tasks or events may be performed in an order other than that specifically disclosed, or multiple may be combined in a single block or state. The example tasks or events may be performed in serial, in parallel, or in some other manner. Tasks or events may be added to or removed from the disclosed example embodiments. The example systems and components described herein may be configured differently than described. For example, elements may be added to, removed from, or rearranged compared to the disclosed example embodiments.
While certain example embodiments have been described, these embodiments have been presented by way of example only, and are not intended to limit the scope of the inventions disclosed herein. Thus, nothing in the foregoing description is intended to imply that any particular feature, characteristic, step, module, or block is necessary or indispensable. Indeed, the novel methods and systems described herein may be embodied in a variety of other forms; furthermore, various omissions, substitutions and changes in the form of the methods and systems described herein may be made without departing from the spirit of the embodiments disclosed herein.

## Claims

1. A data storage device comprising:
a disk comprising a plurality of tracks, wherein at least two of the tracks comprise a thermal asperity;
a head actuated over the disk; and
control circuitry configured to seek the head from a first track to a second track by at least:
for each of at least two of the thermal asperities:
when an undelayed seek will cause the head to hit the thermal asperity, computing a minimum seek delay and a maximum seek delay that will cause the head to miss the thermal asperity; and
when the undelayed seek will cause the head to miss the thermal asperity, computing an allowed seek delay range that will cause the head to miss the thermal asperity; and

when the undelayed seek will cause the head to hit at least one of the thermal asperities, delaying the seek by a seek delay determined based on the minimum seek delays, the maximum seek delays, and the allowed seek delay ranges.

2. The data storage device as recited in claim 1, wherein the seek delay comprises a minimum seek delay determined based on the minimum seek delays, the maximum seek delays, and the allowed seek delay ranges.

3. The data storage device as recited in claim 2, wherein for one of the thermal asperities the control circuitry is further configured to compute the minimum seek delay and the maximum seek delay according to:




  {
  
     
    
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              <
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
    
  



i represents an index for the thermal asperity;
tmin,i represents the minimum seek delay;
tmax,i represents the maximum seek delay;
wi represents a servo wedge in the thermal asperity where the head will hit the thermal asperity during the undelayed seek;
wi0 and wi1 represent servo wedges that define a boundary of the thermal asperity; and
Rev represents a total number of servo wedges in the track comprising the thermal asperity.

4. The data storage device as recited in claim 3, wherein for one of the thermal asperities the control circuitry is further configured to compute the allowed seek delay range according to:


tdε[0,tminNot,i]∪[tmaxNot,i,Rev−1] where






  {
  
     
    
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
                +
                1
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              <
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
            
          
        
      
      
        
          
            
              Rev
              +
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
              -
              
                w
                i
              
              +
              1
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
                +
                1
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
    
  



where:
i represents an index for the thermal asperity; and
td represents the allowed seek delay range.

5. The data storage device as recited in claim 3, wherein the control circuitry is further configured to compute the seek delay by:
for all cases where the head will hit the thermal asperities computing an acceptable delay range according to:


tmin=tmin,i+1, tmax=tmax,i−1


if tmin≦tminNot,i for all cases where the head will miss the thermal asperities then setting the seek delay equal to tmin, otherwise for each case where the head will miss the thermal asperities if tmin>tminNot,i then tmin=tmaxNot,i.

6. The data storage device as recited in claim 1, wherein the control circuitry is further configured to:
store a plurality of access commands in a command queue; and
execute a rotational position optimization (RPO) algorithm to determine an execution order for the access commands based on the seek delay determined for at least two of the access commands.

7. A method of operating a data storage device, the method comprising:
seeking a head over a disk from a first track to a second track by at least:
for each of at least two of a plurality of thermal asperities on the disk:
when an undelayed seek will cause the head to hit the thermal asperity, computing a minimum seek delay and a maximum seek delay that will cause the head to miss the thermal asperity; and
when the undelayed seek will cause the head to miss the thermal asperity, computing an allowed seek delay range that will cause the head to miss the thermal asperity; and

when the undelayed seek will cause the head to hit at least one of the thermal asperities, delaying the seek by a seek delay determined based on the minimum seek delays, the maximum seek delays, and the allowed seek delay ranges.

8. The method as recited in claim 7, wherein the seek delay comprises a minimum seek delay determined based on the minimum seek delays, the maximum seek delays, and the allowed seek delay ranges.

9. The method as recited in claim 8, wherein for one of the thermal asperities the method further comprises computing the minimum seek delay and the maximum seek delay according to:




  {
  
     
    
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  min
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                t
                
                  max
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              <
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
    
  



where:
i represents an index for the thermal asperity;
tmin,i represents the minimum seek delay;
tmax,i represents the maximum seek delay;
wi represents a servo wedge in the thermal asperity where the head will hit the thermal asperity during the undelayed seek;
wi0 and wi1 represent servo wedges that define a boundary of the thermal asperity; and
Rev represents a total number of servo wedges in the track comprising the thermal asperity.

10. The method as recited in claim 9, wherein for one of the thermal asperities the method further comprises computing the allowed seek delay range according to:


tdε[0,tminNot,i]∪[tmaxNot,i,Rev−1] where






  {
  
     
    
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
                +
                1
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              <
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
            
          
        
      
      
        
          
            
              Rev
              +
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
              -
              
                w
                i
              
              +
              1
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              ≤
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
            ,
            
              
                w
                i
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
      
        
          
            
              
                t
                
                  minNot
                  ,
                  i
                
              
              =
              
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                -
                
                  w
                  i
                
                -
                1
              
            
            ,
            
              
                t
                
                  maxNot
                  ,
                  i
                
              
              =
              
                Rev
                +
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                -
                
                  w
                  i
                
                +
                1
              
            
            ,
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  w
                  
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
              
              >
              
                w
                
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
              
            
          
        
      
    
  



where:
i represents an index for the thermal asperity; and
td represents the allowed seek delay range.

11. The method as recited in claim 9, further comprising computing the seek delay by:
for all cases where the head will hit the thermal asperities computing an acceptable delay range according to:


tmin=tmin,i+1, tmax=tmax,i−1


if tmin≦tminNot,i for all cases where the head will miss the thermal asperities then setting the seek delay equal to tmin, otherwise for each case where the head will miss the thermal asperities if tmin>tminNot,i then tmin=tmaxNot,i.

12. The method as recited in claim 7, further comprising:
storing a plurality of access commands in a command queue; and
executing a rotational position optimization (RPO) algorithm to determine an execution order for the access commands based on the seek delay determined for at least two of the access commands.