Abstract:
At least one rotating memory medium such as a hard disk is installed in a hard disk drive or the like. The disk drive has a controller, controller memory and one or more heads for writing and reading to and from one or both sides of the disk. The disk is scanned for defects as sector locations, servo wedges and other information are recorded on tracks on the disk. Some unused space is reserved around the track to compensate for the area lost to defects. If a defect is detected in a sector, the sector is split into first and second parts on either side of the defective space. The location of the defective space is recorded in the controller memory and is processed like a servo wedge. In this manner, only part of the sector is lost due to the defect.

Description:
[0001]    This invention relates to methods and apparatus for formatting memory media, and more particularly, to methods and apparatus for isolating defects in the memory media for data recording/reproducing purposes, without isolating the entire sector in which a defect is found. 
       BACKGROUND OF THE INVENTION 
       [0002]    In conventional hard disk drives and the like, a rotating memory media is divided into circumferential tracks. Data is written to and read from the tracks by read and write heads. The location of the heads is controlled using servo information which is written on the disk at the time of manufacture, through a formatting process. 
         [0003]    Servo information typically includes several wedges that extend radially from the center of the disk, across all of the tracks. The servo wedges are only used for tracking purposes, not data recording purposes. 
         [0004]    For recording purposes, the tracks are divided into sectors. Today&#39;s sectors each typically store 512 bytes of user data. For processing purposes, the bytes are often grouped into 10-bit symbols. The symbol length is determined by the encoding method used by the read/write channel, and error correction code ECC. 
         [0005]    The lineal length of all of the sectors is substantially equal, but the lineal distance between servo wedges changes constantly, because the wedges extend radially from the center of the media. As a result, a portion of a sector or a number of sectors can be recorded between adjacent servo wedges. In fact, a sector can be divided into two parts, one on either side of a servo wedge. 
         [0006]    This conventional arrangement records data on the tracks in a fairly efficient manner, but if even a small defect is detected in a sector in the servo writing or other formatting process, the entire sector is not used. This is an inefficient use of disk space. Accordingly, there is a need for methods and apparatus for more efficiently isolating defects in memory media when the media is formatted, without isolating an entire sector in which a defect is found. 
       SUMMARY OF THE INVENTION 
       [0007]    In keeping with one aspect of this invention, at least one rotating memory medium such as a hard disk is installed in a hard disk drive or the like. The disk drive has a controller, controller memory and one or two heads for writing and reading to and from one or both sides of the disk. The disk is scanned for defects as sector locations, servo wedges and other information are recorded on tracks on the disk. Some unused space is reserved around the track to compensate for the area lost to defects. If a defect is detected in a sector, the sector is split into first and second parts on either side of the defective space. The location of the defective space is recorded in the controller memory and is processed like a servo wedge. In this manner, only part of the sector is lost due to the defect. 
         [0008]    The location of the read/write heads and the recording/reproducing process are supervised by the controller. Today&#39;s controllers anticipate servo wedges by counting sectors and symbols between servo wedges. The number of symbols between servo wedges is pre-recorded in the controller memory. 
         [0009]    When a defect is discovered in the disk during the formatting process, its position is recorded as the number of symbols between the previous servo wedge and the beginning of the defect. In one embodiment, the width of a defect is recorded in the controller memory as defective space. The controller stops data from being recorded in the defective space, and does not expect to read data from the defective space in operation. 
         [0010]    The controller counts the symbols from the end of the servo wedge preceding the unused space and reads/writes data until the number of symbols reaches a predetermined number known to mark the beginning of the next servo wedge or defective space. When the head reaches the end of the servo wedge or defective space, the head starts reading/write operations again, and the controller counts another predetermined number of symbols, to the beginning of the next servo wedge or defective space. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0011]    The above mentioned and other features of this invention and the manner of obtaining them will become more apparent, and the invention itself will be best understood by reference to the following description of an embodiment of the invention taken in conjunction with the accompanying drawings, in which: 
           [0012]      FIG. 1  is a diagram of a memory medium in a disk drive made in accordance with the present invention; 
           [0013]      FIG. 2  is a diagram of the memory medium of  FIG. 1 ; 
           [0014]      FIG. 3  is an example of a conventional track format of the prior art where an entire sector of area is reserved for defects. 
           [0015]      FIG. 4  is an example of a conventional track format where sectors around and after the defect are slipped or skipped. 
           [0016]      FIG. 5  is an example of the track format of the present invention where more than one defect is present. 
           [0017]      FIG. 6  is a block diagram of the disk data path portions of a disk controller using the present invention. 
           [0018]      FIG. 7  is a block diagram of a servo writer for the present invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0019]    Referring to  FIG. 1 , a hard disk drive  10  includes at least one disk medium  12 , in a case  14 . Also enclosed in the case  14  are an actuator  16  driven by a voice coil motor  18 , a suspension  20  secured to the actuator  16 , and a slider  22 . The slider  22  has a write head and a read head (not shown in  FIG. 1 ). In operation, the recording medium  12  is rotated, and the slider  22  is positioned over the disk radially as the write head writes data to the rotating disk and the read head reads data from the rotating disk. The slider  22  is moved across the disk radially in the directions of an arrow  23  for seeking or changing tracks. 
         [0020]    Data is recorded on circumferential tracks  30 , shown in  FIG. 2 . Each track  30  is divided in to data wedges  32  and servo wedges  34 . Servo information recorded in the servo wedges  34  is used to control the location of the heads over the tracks. As seen in  FIG. 2 , the data wedges  32  and servo wedges  34  extend radially from the center of the disk. The linear circumferential lengths of the data and servo wedges are relatively short near the center of the medium  12 , and become progressively longer on the outer radial tracks. 
         [0021]    User data is recorded on the tracks in generally equal sectors, as seen in  FIG. 3 . The user data typically includes all synchronization, training, error correction codes (ECC), and all speed tolerances or other information needed to store data reliably. Generally, a sector is the area between start of sector (SOS) pulses. Each sector has enough space or area to record a predetermined number of data symbols. The area is defined by a number of clock pulses or clocks corresponding to the number of symbols. It is not unusual to divide a track into 10 data sectors (sector  0 - 9 ), and reserve an eleventh sector (spare  0 ) in the event that defects are found in one of the sectors. In a conventional drive, defective sectors are not used, as seen in  FIG. 4 . In  FIG. 4 , the sector  6  in  FIG. 3  has a defect, so sector  7  in  FIG. 3  is designated sector  6  in  FIG. 4 , the remaining sectors are renumbered, and spare sector  0  in  FIG. 3  is used as sector  9  in  FIG. 4 . 
         [0022]    Because the sector length is constant and the data cylinders  32  are not constant, it is not unusual for a sector to be divided across a servo wedge  34 . User data is not written to or read from the servo wedges  34 , so the recording must stop at the beginning of a servo wedge, and resume after the head passes the servo wedge. This is accomplished by a controller  50  ( FIG. 1 ), shown in detail in  FIG. 6 . 
         [0023]    Generally, the controller  50  includes a microprocessor or the like  52  that is programmed to perform the functions that will now be described. The MPU has an input/output port  54  for receiving and sending data to a host device such as a computer  56 , volatile cache memory  58  for storing data and other information, a DRAM  60  for operating the MPU  52  and storing user data, and the same or another DRAM  62  used for controlling read and write operations of the head. 
         [0024]    Some of the algorithms used by the MPU  52  are indicated generally in  FIG. 6  at  64 . The head control algorithms  64  include algorithms  66  for controlling the position of the actuator  16  through the servo motor  18 , and other algorithms  68  that are used to essentially turn the read and write heads on and off. Among other things, the read/write control algorithms  68  include sector generator algorithms  70 , which use prerecorded data in the DRAM  62  to produce up-date registers  71  used to control the read and write heads. In practice, many of the functions of these algorithms are performed by hardware. The algorithms can be performed by the MPU, which then programs the different hardware blocks as the algorithms require. 
         [0025]    The data stored in the DRAM  62  is generated when the medium  12  is formatted by a disk formatter  80 , shown in  FIG. 7 . The disk formatter  80  includes a controller  82  programmed with sector generator algorithms  83  for defining the concentric tracks on the medium  12  using a write head  86 , and a read head  87  and generating and storing track definition tables  84  in a DRAM  85 , and other algorithms for defining data sectors and servo wedges and generating and storing cylinder and servo wedge definition tables  88  in the DRAM  85 , and recording servo information in the servo wedges on the medium  12 . Controller  50  also scans the tracks of the medium  12  for defects and stores a location of each defect in a memory  90 . The data in the memory  90  and DRAM  85  is transferred to the disk drive media of  FIG. 1 , if needed. 
         [0026]    An example of a split sector with defects is seen in  FIG. 5A . 
         [0027]    Sector  4  has a defect, so it is split across the defect, using a portion of the spare sector  0  in  FIG. 3 . Sector  7  also has a defect, and is split across the defect using more of the space allocated to spare sector  0  in  FIG. 3 , leaving the remainder of spare sector  0  unassigned. If there were additional defects, and there were no unassigned space from the spare sector  0 , sector  9  would be recorded in the next zone or cylinder. 
         [0028]    The manner in which the defects are skipped is shown in greater detail in  FIG. 5B . After resynchronizing the head in a track space  90 , data is recorded in space  91 . Data is not recorded in defect space  92 , so a second resychronization space  93  is provided, and data is recorded in the space  94 , until a servo wedge  95  is reached. After the servo wedge  95 , the head passes a resynchronizing zone  96 , followed by another data zone  97 . After defect  98 , another resynchronizing space  99  is provided followed by data space  100  and an error correction code (ECC) space  101 . In this manner, the defect spaces are treated like servo wedges, and the entire sector is not lost. 
         [0029]    Various algorithms are used to perform these functions. They will be described using terms and registers which will now be defined and described. 
         [0030]    The locations of servo wedges are defined by the controller  82  by counting pulses from a first predetermined point to a second predetermined point, identifying the beginning and the end of each servo wedge. The controller  82  also counts or records pulses from the end of each servo wedge, which marks the beginning of a data sector, to the end of the data sector, which marks the starting location of the next succeeding servo wedge. The servo count pulses are recorded on the disk. 
         [0031]    The sector generator  70  uses several registers to establish various disk parameters. One parameter is “start of sector (SOS)” which identifies locations on the disk where the disk formatter begins to write or read a sector. The SOS locations are based upon the “servo count” and “wedge count”. The “servo count” is calculated by a counter running at a rate determined by servo information used to determine the circumferential position of the head on the disk. The number of servo wedges from zero, or “index”, used in conjunction with the servo count to determine the circumferential position on the disk, is referred to as the “wedge count”. A “symbol count” is determined by a counter running at the single rate used by the disk formatter to read or write data. 
         [0032]    The disk formatter also defines “intersector gaps (ISG)”. An ISG is the area on the disk between sectors. 
         [0033]    The formatter defines the “recording zone” on the disk, which is a number of tracks/cylinders all using the same track format and symbol rates. 
         [0034]    The disk formatter identifies “defect locations” by marking the location of the start of a defective area in the “wedge count” and “servo counts”. The “defect length”, or length of the defect in servo counts, is also identified. A “defect table” is formed which can be read from DRAM  85 , and contains defect information for a current “defect zone”. The “symbol defect length” is the length of the defect in symbol clocks. 
         [0035]    A “Split count” parameter is the value used by the disk formatter in symbol counts to begin the split of a sector around either a servo wedge or a defect. A “Min Split” parameter is the smallest area that a sector may be started before having to split around a “servo wedge”. The “Min Split” causes the end of a frame. 
         [0036]    A “ratio parameter” is the ratio between “servo count” and “symbol count”. This value will change in every recording zone. A “Frame” is a repetitive area of the track layout. This is an area where the SOS for the first sector of the frame is immediately after the servo wedge, and the last sector ends closer to a servo wedge than the “Min Split” length. 
         [0037]    A “frame table” is a table from DDR that represents the SOS and split information for a frame. 
         [0038]    A “Go_Indication” parameter is an indication from the formatter that the sector generator should perform a set of calculations. 
         [0039]    “Type” is an input used by Split_Count to determine a defect DFCT or split, and “where” is an input used by Split_Count to determine if DFCT is pre- or post-survey wedge split. 
         [0040]    The sector generator uses these parameters and several registers to control read/write operations. 
         [0041]    The following registers are used on a per recording zone basis: 
         [0042]    SYMBOLS_PER_SECTOR—Symbols per Sector. This register stores the total number of symbols per sector, including ECC, sync fields, and ISG area. 
         [0043]    SVOCLKS_PER_SECTOR—This register stores the total number of servo clocks per sector, including ECC, sync fields, and ISG area. 
         [0044]    SYMBOLS_PER_WEDGE—This register stores the number of symbol clocks per servo Wedge. This value will change from recording zone to recording zone. 
         [0045]    SVOCLKS_PER_WEDGE—This register stores the number of servo clocks per Wedge 
         [0046]    RATIO—This register stores the number of Servo Clocks per Symbol Clock for the current recording zone. 
         [0047]    SECTORS_PER_TRACK—This register stores the number of physical sectors per track. It is used to rollover SECTOR_NUMBER, which will be described later. 
         [0048]    SVO_CNT_AT_START_OF_DATA—This register stores the Servo Count at the first place where an SOS may occur. 
         [0049]    SYMBOLS_PER_RESYNC—This register stores the size of all fields required for resynchronization after a split in Symbol Clocks. 
         [0050]    SVO_CLKS_PER_RESYNC—This register stores the number the size of all fields required for resynchronization after a split in Servo Clocks. 
         [0051]    MIN_SPLIT—This register stores the minimum number of servo clocks required from SOS to a Servo Wedge to allow starting another sector (end of frame). 
         [0052]    The following register is used on a per command basis: 
         [0053]    SECTOR_NUMBER—This register stores the physical sector number for which the SOS is being calculated. 
         [0054]    The following registers are used for local variable storage and calculation results. 
         [0055]    SOS_WEDGE_NUM—This register stores the SOS Wedge number for next sector. 
         [0056]    SOS_SVO_CNT—This register stores the SOS Servo Count value for the next sector. 
         [0057]    CURR_SOS_SVO_CNT—This register is used to determine if a defect or Servo Wedge needs to be split around for the current Sector. This saved version of SOS_SVO_CNT=current 
         [0058]    CURR_SOS_WEDGE_NUM—This register is used in conjunction with CURR_SOS_SVO_CNT. 
         [0059]    DFCT_TBL_PTR—and points to the next defect to be evaluated for SOS and Split Count calculations. 
         [0060]    SPLIT_COUNT—This register, the Split Count is adjusted for defects. This register is a first in, first out, or fifo register, and multiple entries per sector are accommodated. 
         [0061]    RESUME_COUNT—This register stores the location to the start Resync Field. This register is a fifo, and multiple entries per sector are accommodated. 
         [0062]    SPLIT_COUNT_SYMBOL—This register stores the Split Count in symbol clock values. This register is a temporary variable. 
         [0063]    DFCT_ACCUMULATOR—This register accumulates defect lengths from the start to end of a track, and is used to aid split calculations 
         [0064]    CURR_SECTOR_NUMBER—This register stores the Sector number that the heads are currently passing over. 
         [0065]    SPLIT_NEEDED—This register is used to be sure that splits across a servo wedge are calculated after all defects that precede the servo wedge. A split data field across a servo wedge is necessary for this sector. 
         [0066]    The sector generator retrieves, or uses a defect table stored in DRAM for each Defect Zone containing the locations of defects (Defect_Location_Wedge), the starting point of each defect as measured by servo clock signals from the start of the defective area (Defect_Location_Servo_Clocks), and the length of the defect, also measured in servo clocks (Defect_Length_Servo_Clocks). 
         [0067]    Start Of Sector calculations are performed when the controller begins to calculate information in search of a target sector. The SOS for the next sector is calculated, while the Split Counts for the current sector are calculated. This is performed once per sector after that. Once the current information has been used by the formatter, an indication is sent to the sector generator, and the next iteration of the “for” loop for i from CURR_SECTOR_NUMBER to SECTOR_NUMBER on the next page is performed. 
         [0068]    The following pseudo code is instructive in understanding this process. The pseudo code is similar to C programming, and can be performed by either a state machine or a microprocessor. 
       Pseudo-Code Definitions: 
       [0069]      
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 // 
                 = comments 
               
               
                   
                 { } 
                 = start and end of a complex statement. 
               
               
                   
                 ; 
                 = end of a statement 
               
               
                   
                 &amp;&amp; 
                 = logical and 
               
               
                   
                 || 
                 = logical or 
               
               
                   
                 ( ) 
                 = evaluate this term prior to other terms in an equation 
               
               
                   
                 += 
                 = increment 
               
               
                   
                 −= 
                 = decrement 
               
               
                   
                 &gt;= 
                 = greater than or equal 
               
               
                   
                 &lt;= 
                 = less than or equal 
               
               
                   
                 != 
                 = not equal 
               
               
                   
                 % 
                 = modulo 
               
               
                   
                 = 
                 = assignment 
               
               
                   
                 == 
                 = equality 
               
               
                   
                 [ ] 
                 = index into a table or array 
               
               
                   
                   
               
             
          
         
       
     
       Start of Sector Calculator Pseudo-code 
       [0070]    This pseudo-code is executed when the formatter starts to calculate information for the target sector. The SOS for the next sector is calculated, while the split counts for the current sectors are calculated. The pseudo-code is performed once per sector after that. Once the current information has been used by the formatter, an indication is sent to the sector generator, and the next iteration of the loop is performed. 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 DFCT_TBL_PTR = 0; DFCT_ACCUMULATOR = 0; 
               
               
                 CURR_SECTOR_NUMBER = ffh; Initial value of FFh allows the first increment 
               
               
                 to make this 0, as explained in comments below also. 
               
               
                 SOS_WEDGE_NUM = 0; SOS_SVO_CNT = 
               
               
                 SVO_CNT_AT_START_OF_DATA; 
               
               
                 CURR_SOS_WEDGE_NUM = SOS_WEDGE_NUM; CURR_SOS_SVO_CNT = 
               
               
                 SOS_SVO_CNT; DFCT_ACCUMULATOR = 0; 
               
               
                 // Calculate SOS from beginning of track (sector 0) to requested SECTOR_NUMBER 
               
               
                 // once the calculations from CURR_SECTOR_NUMBER to SECTOR_NUMBER 
               
               
                 occurs, possibly 
               
               
                 // causing multiple loops through the loop, the calculation will be performed once per 
               
               
                 sector only. 
               
               
                 for i from CURR_SECTOR_NUMBER to SECTOR_NUMBER { 
               
               
                  // wait here for indication from formatter that it is time to begin a new sector&#39;s 
               
               
                 calculation 
               
               
                  while ( go_indication != TRUE) { }; 
               
               
                  // Initialization 
               
               
                  // values calculated the previous time through the loop are now valid as current 
               
               
                  // first time through, CURR_SECTOR_NUMBER = ff, Initial value of FFh allows 
               
               
                 the first increment to make this 0 so this increment makes it 0. 
               
               
                  CURR_SECTOR_NUMBER += 1; 
               
               
                  CURR_SOS_WEDGE_NUM = SOS_WEDGE_NUM; 
               
               
                  CURR_SOS_SVO_CNT = SOS_SVO_CNT; 
               
               
                  SPLIT_NEEDED = 0; 
               
               
                  // increment SECTOR_NUMBER % SECTORS_PER_TRACK once the original 
               
               
                 requested sector 
               
               
                  // has been reached. Otherwise hold SECTOR_NUMBER as is. 
               
               
                  if CURR_SECTOR_NUMBER == SECTOR_NUMBER { 
               
               
                   SECTOR_NUMBER += 1; }; 
               
               
                  // Rollover needed? 
               
               
                  if SECTOR_NUMBER &gt;= SECTORS_PER_TRACK {SECTOR_NUMBER = 
               
               
                 0}; 
               
               
                   
               
             
          
         
       
     
         [0071]    The following calculation is used to generate the information necessary to locate the beginning of the Resync area  90  ( FIG. 5B ) for each sector. There are adjustments to this based on defect information and servo wedge. 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                  // Start of Calculations 
               
               
                  // Add a Sector&#39;s worth of Servo Clocks 
               
               
                  SOS_SVO_CNT += SVOCLKS_PER_SECTOR; 
               
               
                  // if SOS_SVO_CNT &gt; SVOCLKS_PER_WEDGE, increment 
               
               
                 SOS_WEDGE_NUM and adjust 
               
               
                  // SOS_SVO_CNT 
               
               
                  // checks if a split occurs, and adjusts SOS_SVO_CNT, and SOS_WEDGE_NUM 
               
               
                 accordingly 
               
               
                  // checks for MIN_SPLIT also 
               
               
                  call check_split_needed( ); 
               
               
                  // Now see if adjustments for defects are needed? 
               
               
                  // if the next entry in the defect_table is between the Current SOS and SOS, or the end 
               
               
                 of the data wedge for a sector 
               
               
                  // split around a servo wedge, then adjust for that defect 
               
               
                  // while loop in order to process multiple defects or splits per sector. First loop 
               
               
                 calculates to end of 
               
               
                  // sector, or the end of data wedge. 
               
               
                   
               
             
          
         
       
     
         [0072]    The next loop is used after a split across a servo wedge. This calculation determines if a defect  92  in  FIG. 5B  is located for the current sector. 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                  while ( Defect_Table[DFCT_TBL_PTR] [Defect_Location_Wedge] == 
               
               
                 CURR_SOS_WEDGE_NUM &amp;&amp; 
               
               
                   Defect Table[DFCT_TBL_PTR] [Defect_Location_Servo_Clocks] &gt;= 
               
               
                 CURR_SOS_SVO_CNT &amp;&amp; 
               
               
                   Defect_Table[DFCT_TBL_PTR] [Defect_Location_Servo_Clocks] &lt;= 
               
               
                 (SOS_SVO_CNT || SVOCLKS_PER_WEDGE) ) { 
               
               
                    // slip current SOS_SVO_CNT by Defect Length 
               
               
                    SOS_SVO_CNT += Defect_Table[DFCT_TBL_PTR] 
               
               
                 [Defect_Length_Servo_Clocks] ; 
               
               
                    // checks if a split occurs, and adjusts SOS_SVO_CNT, and 
               
               
                 SOS_WEDGE_NUM 
               
               
                    // accordingly, checks for MIN_SPLIT also 
               
               
                    call check_split_needed( ); 
               
               
                    if SPLIT_NEEDED == 1 { call split_count_calc(dfct,pre); This returns 
               
               
                 results used to determine actual values for the defects 92 and the resync fields 93 in 
               
               
                 FIG. 5B. 
               
               
                     // after the defect, see if a split sector is now necessary? 
               
               
                     call check_split_needed( );}; 
               
               
                    DFCT_TBL_PTR ++ ; // increment pointer each time through while loop 
               
               
                  }; // end of while 
               
               
                   // all defects up to servo wedge or end of sector have been processed, normal split 
               
               
                 around servo 
               
               
                   // wedge needed? 
               
               
                   // may not have been needed before defect processing, so also check to see if a split 
               
               
                 across a servo 
               
               
                   // wedge will now happen? 
               
               
                   if SPLIT_NEEDED || ((SOS_SVO_CNT &gt; SVOCLKS_PER_WEDGE) &amp; 
               
               
                 (SOS_SVO_CNT &gt;= MIN_SPLIT)) { 
               
               
                    call split_count_calc(split,pre); This returns results used to determine values for 
               
               
                 the servo wedge 95 and resync field 96 in FIG. 5B. 
               
               
                    SPLIT_NEEDED = 0;}; 
               
               
                   // if the sector has been split across a servo wedge, then determine if there are any 
               
               
                 defects between 
               
               
                   // the beginning of the data wedge and the end of the current sector 
               
               
                   // was the sector split? 
               
               
                   if CURR_SOS_WEDGE_NUM != SOS_WEDGE_NUM { 
               
               
                    while ( Defect_Table[DFCT_TBL_PTR] [Defect_Location_Wedge] == 
               
               
                 SOS_WEDGE_NUM &amp;&amp; Defect_Table[DFCT_TBL_PTR] 
               
               
                 [Defect_Location_Servo_Clocks] &lt;= SOS_SVO_CNT ) { 
               
               
                     // slip current SOS_SVO_CNT by Defect Length 
               
               
                     SOS_SVO_CNT += Defect_Table[DFCT_TBL_PTR] 
               
               
                 [Defect_Length_Servo_Clocks]; 
               
               
                     call check_split_needed( ); 
               
               
                     if SPLIT_NEEDED == 1 { call split_count_calc(dfct,pre); // This returns 
               
               
                 results used to determine actual values for the defect 98 and resync field 99 in FIG. 5B. 
               
               
                     // increment pointer, look for next defect 
               
               
                     DFCT_TBL_PTR ++ ; // increment pointer each time through while loop 
               
               
                   }; // end of while 
               
               
                  }; // end of if 
               
               
                 }; // end of big for loop 
               
               
                   
               
             
          
         
       
     
         [0073]    Split counts can be calculated along the lines of the following pseudo code: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 spilt_count_calc( ); 
               
               
                 // Entered with a valid DFCT_TBL_PTR, CURR_SOS_SVO_CNT, and 
               
               
                 SOS_SVO_CNT 
               
               
                 // also an input of dfct or split to determine if the defect table info is used, or normal split 
               
               
                 // across a servo wedge information 
               
               
                 input type; // dfct or split 
               
               
                 // need to know if the defect is pre or post a servo wedge split 
               
               
                 input where; // pre or post 
               
               
                 // it has already been determined that a split is going to happen, so no bounds checking 
               
               
                 is needed 
               
               
                 if type == dfct { 
               
               
                  // Number of Servo Clocks from CURR_SOS_SVO _CNT to start of defect 
               
               
                  if where == pre { SPLIT_COUNT = Defect_Table[DFCT_TBL_PTR] 
               
               
                   [Defect_Location_Servo_Clocks] + CURR_SOS_SVO_CNT + 
               
               
                   DFCT_ACCUMULATOR; 
               
               
                  }; 
               
               
                  else { // where = post 
               
               
                   SPLIT_COUNT = Defect_Table[DFCT_TBL_PTR] 
               
               
                 [Defect_Location_Servo_Clocks] − 
               
               
                    SVO_CNT_AT_START_OF_DATA + DFCT_ACCUMULATOR; }; 
               
               
                 // type == split 
               
               
                 else { 
               
               
                  // Number of Servo Clocks from CURR_SOS_SVO_CNT to end of data wedge 
               
               
                  SPLIT_COUNT = SVOCLKS_PER_WEDGE − CURR_SOS_SVO_CNT; 
               
               
                  SPLIT_COUNT_SYMBOL_SAVE = SPLIT_COUNT_SYMBOL; }; 
               
               
                 // convert from servo clocks to symbols 
               
               
                 SPLIT_COUNT_SYMBOL = SPLIT_COUNT * RATIO; 
               
               
                 // Adjust SPLIT_COUNT to get true Symbol Count value for the SPLIT_COUNT 
               
               
                 SPLIT_COUNT_SYMBOL −= SYMBOLS_PER_RESYNC; 
               
               
                 if (split &amp;&amp; post == TRUE) { SPLIT_COUNT_SYMBOL += 
               
               
                  SPLIT_COUNT_SYMBOL_SAVE; 
               
               
                 // don&#39;t add to DFCT_ACCUMULATOR if this is split around servo wedge 
               
               
                 if type == dfct { 
               
               
                  DFCT_ACCUMULATOR += Defect_Table[DFCT_TBL_PTR] 
               
               
                 [Defect_Length_Servo_Clocks]; }; 
               
               
                 // now calculate RESUME_COUNT 
               
               
                 if type == dfct { 
               
               
                  RESUME_COUNT = SPLIT_COUNT + Defect_Length_Servo_Clocks; }; 
               
               
                 else { 
               
               
                  RESUME_COUNT = SVO_CNT_AT_START_OF_DATA; }; 
               
               
                 // done, return to caller 
               
               
                 return; 
               
               
                   
               
             
          
         
       
     
         [0074]    The following calculation used to determine if a split around a servo wedge is needed. This is  FIG. 5B  ( 94 ,  95 ). The data field  94  encounters the servo wedge before the end of the sector, so the split is necessary, thus this calculation is necessary. 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 check_split_needed( ); 
               
               
                  // this subroutine assumes all variables referenced are valid when called 
               
               
                  if SOS_SVO_CNT &gt; SVOCLKS_PER_WEDGE { 
               
               
                   SPLIT_NEEDED = 1; 
               
               
                   // split sector across servo wedge, check for end of frame, and if not, add 
               
               
                   // SVO_CLKS_PER_RESYNC to SOS_SVO_CNT 
               
               
                   if (SVOCLKS_PER_WEDGE − SOS_SVO_CNT) &gt;= MIN_SPLIT { 
               
               
                    SOS_SVO_CNT += SVO_CLKS_PER_RESYNC; 
               
               
                    // subtract SVOCLKS_PER_WEDGE to get raw value for far side of wedge 
               
               
                    // and add SVO_CNT_AT_START_OF_DATA to get true SOS for next sector 
               
               
                 SOS_SVO_CNT = SOS_SVO_CNT − SVOCLKS_PER_WEDGE + 
               
               
                  SVO_CNT_AT_START_OF_DATA; 
               
               
                    // must increment wedge number since we split across a wedge, and new SOS is 
               
               
                 in next wedge. 
               
               
                    // mod WEDGES_PER_TRACK is for rollover to wedge number 0. 
               
               
                    (SOS_WEDGE_NUM += 1) % WEDGES_PER_TRACK; }; 
               
               
                   // else (SVOCLKS_PER_WEDGE − SOS_SVO_CNT) &lt; MIN_SPLIT 
               
               
                   // and it is a frame boundary, waste space and start over after Servo Wedge 
               
               
                   else {SOS_SVO_CNT = SVO_CNT_AT_START_OF_DATA; 
               
               
                     (SOS_WEDGE_NUM += 1) % WEDGES_PER_TRACK; 
               
               
                     SPLIT_NEEDED = 0; }; 
               
               
                  // else no split, SOS and wedge number are correct after raw addition above 
               
               
                  else { SPLIT_NEEDED = 0}; 
               
               
                  return( ); 
               
               
                   
               
             
          
         
       
     
         [0075]    The pseudo code for performing the functions needed to develop the fields in  FIGS. 5A and 5B  could be executed generally as follows: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 SVOCLKS_PER_SECTOR = 0x681; 
               
               
                 SYMBOLS_PER_SECTOR = 0x1042, 0x1000 = data; 0x2e = ECC; Resync Field = 
               
               
                 0x14 
               
               
                 RATIO is 2.5 symbols per servo clock; 
               
               
                 CURR_SOS_WEDGE_NUM = 5; 
               
               
                 CURR_SOS_SVO_CNT = 0x447f; 
               
               
                 MIN_SPLIT = 0x40; 
               
               
                 SVO_CNT_AT_START_OF_DATA = 0x80; 
               
               
                 SVO_CLKS_PER_RESYNC = 0x13; 
               
               
                 SYMBOLS_PER_RESYNC = 0x30; 
               
               
                 SVOCLKS_PER_WEDGE = 0x4800; 
               
               
                 Defect in first wedge 
               
               
                 Defect_Location_Wedge = 5; Defect_Location_Servo_Clocks = 0x4600; 
               
               
                 Defect_Length_Servo_Clocks = 0x30; 
               
               
                 Defect in second wedge 
               
               
                 Defect_Location_Wedge = 6; Defect_Location_Servo_Clocks = 0x210; 
               
               
                 Defect_Length_Servo_Clocks = 0x28; 
               
               
                  CURR_SECTOR_NUMBER = 4; 
               
               
                   SECTOR_NUMBER = 5; 
               
               
                 SPLIT_COUNT_SYMBOL_SAVE = 0; 
               
               
                   
               
             
          
         
       
     
       Start of Calculations 
       [0076]    This section lists the calculations from the pseudo-code above, and shows the results. Subroutine calls are shown with the results of calculations performed in the subroutines. This section is used to generate the Resync field  90  in  FIG. 5B  ( 90 ). 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                  CURR_SECTOR_NUMBER = SOS_SVO_CNT = 5; 
               
               
                  CURR_SOS_WEDGE_NUM = SOS_WEDGE_NUM = 5; 
               
               
                  CURR_SOS_SVO_CNT = SOS_SVO_CNT = 0x447f; 
               
               
                  call check_split_needed( ); 
               
               
                   SOS_SVO_CNT = 0x447f + 0x681 = 0x4b00; 
               
               
                   SPLIT_NEEDED = 1; 
               
               
                   SOS_WEDGE_NUM += 1 = 6; 
               
               
                   return; 
               
               
                  SOS_SVO_CNT += SVO_CLKS_PER_RESYNC = 0x4b13; 
               
               
                  SOS_SVO_CNT = SOS_SVO_CNT − SVOCLKS_PER_WEDGE + 
               
               
                   SVO_CNT_AT_START_OF_DATA = 0x4b13 − 0x4800 + 0x80 = 0x393; 
               
               
                  // Now see if adjustments for defects are needed? 
               
               
                  // if next entry in defect table is between Current SOS and SOS, or end of data 
               
               
                 wedge, then adjust for 
               
               
                  // that defect (This calculates the defect 92 and the Resync field 93 in Fig. 5B) 
               
               
                  while (Defect_Location_Wedge == CURR_SOS_WEDGE_NUM = 5, 5 = TRUE 
               
               
                 &amp;&amp; 
               
               
                    Defect_Location_Servo_Clocks &gt;= CURR_SOS_SVO_CNT = 0x4600 &gt; 
               
               
                 0x447f &amp;&amp; 
               
               
                    Defect_Location_Servo_Clocks &lt;= (SOS_SVO_CNT || 
               
               
                 SVOCLKS_PER_WEDGE) ) &lt; 0x4800; 
               
               
                    SOS_SVO_CNT += Defect_Length_Servo_Clocks = 0x393 + 0x30 = 0x3c3; 
               
               
                    call check_split_needed( ); 
               
               
                     SPLIT_NEEDED == 1 
               
               
                    call split_count_calc(dfct,pre); 
               
               
                     SPLIT_COUNT = Defect_Location_Servo_Clocks − 
               
               
                 CURR_SOS_SVO_CNT + 
               
               
                      DFCT_ACCUMULATOR; = 0x4600 − 0x447f + 0 = 0x181; 
               
               
                     SPLIT_COUNT_SYMBOL = SPLIT_COUNT * RATIO = 0x3c2; 
               
               
                     SPLIT_COUNT_SYMBOL −= SYMBOLS_PER_RESYNC = 0x3c2 − 
               
               
                 0x30 = 0x392; 
               
               
                     DFCT_ACCUMULATOR += Defect_Length_Servo_Clocks = 0x30; 
               
               
                  RESUME_COUNT = SPLIT_COUNT + Defect_Length_Servo_Clocks = 0x181+ 
               
               
                 0x28 = 
               
               
                   0x1a9; 
               
               
                     return; 
               
               
                    call check_split_needed( ); 
               
               
                     SPLIT_NEEDED == 1 
               
               
                      DFCT_TBL_PTR ++ ; // increment pointer each time through while 
               
               
                 loop 
               
               
                  }; // end of while 
               
               
                  // all defects up to servo wedge or end of sector have been processed, normal split 
               
               
                 around servo 
               
               
                  // wedge needed? (This calculates values for 95 and 96) 
               
               
                  if SPLIT_NEEDED || ((SOS_SVO_CNT &gt; SVOCLKS_PER_WEDGE) &amp; 
               
               
                 (SOS_SVO_CNT &gt;= MIN_SPLIT)) = SPLIT_NEEDED = TRUE; 
               
               
                   call split_count_calc(split,pre); 
               
               
                    SPLIT_COUNT = SVOCLKS_PER_WEDGE − CURR_SOS_SVO_CNT 
               
               
                 + 
               
               
                     DFCT_ACCUMULATOR = 0x4800 − 0x447f + 0x30 = 0x3b1 
               
               
                    SPLIT_COUNT_SYMBOL = SPLIT_COUNT * RATIO = 0x93a; 
               
               
                    SPLIT_COUNT_SYMBOL −= SYMBOLS_PER_RESYNC = 0x93a − 0x30 
               
               
                 = 0x90a; 
               
               
                    SPLIT_COUNT_SYMBOL_SAVE = SPLIT_COUNT_SYMBOL = 0x93a; 
               
               
                 RESUME_COUNT = SVO_CNT_AT_START_OF_DATA = 0x80; 
               
               
                    SPLIT_NEEDED = 0;}; 
               
               
                     return; 
               
               
                  // if the sector has been split across a servo wedge, then determine if there are any 
               
               
                 defects between 
               
               
                  // the beginning of the data wedge and the end of the current sector 
               
               
                 // was the sector split? (This calculates the defect 98 and the resync field 99 in Fig. 
               
               
                 5B) 
               
               
                  if CURR_SOS_WEDGE_NUM != SOS_WEDGE_NUM = 5, 6 = TRUE 
               
               
                   while (Defect_Location_Wedge == SOS_WEDGE_NUM = 5 = 5 = TRUE &amp;&amp; 
               
               
                    Defect_Location_Servo_Clocks &lt;= SOS_SVO_CNT = 0x110 &lt; 0x3c3 = 
               
               
                 TRUE 
               
               
                    SOS_SVO_CNT += Defect_Length_Servo_Clocks = 0x3c3 + 0x28 = 0x3cb; 
               
               
                    call split_count_calc(dfct,post); 
               
               
                   SPLIT_COUNT = Defect_Location_Servo_Clocks − 
               
               
                    SVO_CNT_AT_START_OF_DATA + DFCT_ACCUMULATOR; = 
               
               
                 0x210 − 0x80 + 
               
               
                    0x30 = 0x1c0; 
               
               
                      SPLIT_COUNT_SYMBOL = SPLIT_COUNT * RATIO = 0x460; 
               
               
                      SPLIT_COUNT_SYMBOL −= SYMBOLS_PER_RESYNC = 0x460 
               
               
                 − 0x30 = 0x430; 
               
               
                    if (split &amp;&amp; post == TRUE) { SPLIT_COUNT_SYMBOL += = TRUE 
               
               
                     SPLIT_COUNT_SYMBOL_SAVE = 0x430 + 0x93a = 0xd6a; 
               
               
                      DFCT_ACCUMULATOR += Defect_Length_Servo_Clocks = 0x30 + 0x28 
               
               
                 = 0x58; 
               
               
                    RESUME_COUNT = SPLIT_COUNT + Defect_Length_Servo_Clocks = 
               
               
                 0x1c0 + 0x28 = 0x1e8; 
               
               
                       DFCT_TBL_PTR ++ ; // increment pointer each time through 
               
               
                 while loop return; 
               
               
                 // end of calculations, done, return to top and wait for go_indication 
               
               
                   
               
             
          
         
       
     
         [0077]    Using the pseudocode just described or similar pseudocode in algorithms, defects can be isolated for data recording/reproducing purposes, without isolating the entire sector in which a defect is found. 
         [0078]    While the principles of the invention have been described above in connection with specific apparatus and applications, it is to be understood that this description is made only by way of example and not as a limitation on the scope of the invention.