Error correction/detection code adjustment for known data pattern substitution

[0001] The present invention relates to techniques for updating cyclic redundancy check bytes in a data storage system, and more particularly, to techniques for updating cyclic redundancy check bytes to correspond to a reassigned logical block address.

[0002] A computer host system can store bytes of data onto a magnetic hard disk using a disk drive. The disk drive writes the data bytes onto the magnetic hard disk using a write element. Disk drives systems typically write data bytes onto disks in 512 byte long sectors. Each sector is associated with a logical block address (LBA) that identifies the location of the sector on the disk. The host system transfers data bytes and corresponding LBAs for each sector to the disk drive.

[0003] The disk drive generates error correction code (ECC) check bytes and cyclic redundancy check (CRC) bytes to correct errors in the data bytes. ECC and CRC engines generate the check bytes as soon as the disk drive receives the data bytes from the host. The ECC and CRC check bytes are used to protect the data bytes from errors using well known encoding processes.

[0004] ECC and CRC engines seed both the data bytes and the LBA into the encoding processes used to generate the ECC and CRC check bytes for each sector. The LBA is not written onto the disk. However, the ECC and CRC engines treat the data bytes and the LBA for a sector as one set of bytes that is used to generate the ECC and CRC check bytes.

[0005] When the disk drive system reads data from the disk, the ECC and CRC engines decode the ECC and CRC bytes to detect and correct errors within the data bytes. The ECC engine points out which of the data bytes within a sector, if any, contain errors. The ECC engine can calculate the location and the value of errors within the sector. For example, the ECC engine may determine that one or more of the data bytes within a sector contain errors. The ECC engine can correct up to a programmable number of errors within the data bytes.

[0006] As another example, the ECC engine may determine that one or more the of LBA bytes that correspond to a sector of data contain errors. If the LBA encoded into the ECC check bytes does not match the LBA from which the data was read, the ECC engine determines that the disk drive read data from the wrong sector.

[0007] Magnetic disks often contain small defects. These defects prevent data from being accurately written onto and read from portions of the disk. Prior art systems have been developed to log the sectors of a disk that contain such defects. These logs record the logical block addresses (LBAs) of the sectors on a particular disk that contain defects. When a host computer system attempts to write data bytes to an LBA, the disk drive system checks to see if that LBA is recorded in the log as an LBA that contains a defect.

[0008] If the LBA for a sector of data is recorded in the defect log list, the disk drive system reassigns the data to a different LBA on the disk that does not contain a defect. The LBA reassignment process occurs after the CRC engine has calculated the CRC check bytes and stored the data and check bytes into DRAM. Thus, the CRC check bytes were calculated based on the old LBA. After the data bytes have been assigned a new sector with a new LBA, the CRC check bytes that were calculated based on the old LBA can no longer be relied upon to correct errors in the data.

[0009] The CRC engine can calculate new CRC bytes using the new LBA and replace the old CRC bytes with the new CRC bytes. However, this process uses a substantial amount of system time.

[0010] Also, the CRC engine must recalculate the CRC bytes based on data bytes that have temporarily been stored in DRAM before they are written onto the disk. The DRAM often introduces errors into the data bytes depending on the soft error rate of the DRAM. If the DRAM introduces errors into the data bytes, the new CRC bytes will be based on corrupted data bytes. Thus, if the new CRC bytes are subsequently used to detect errors in the sector, the CRC engine will restore the data bytes to the corrupted data values.

[0011] Therefore, it would be desirable to provide faster and more accurate techniques for updating CRC check bytes for data bytes that have been reassigned to a new LBA.

[0012] The present invention provides techniques for updating cyclic redundancy check (CRC) bytes for data sectors that have been reassigned to a new logical block address (LBA). The entire set of CRC check bytes is not recalculated each time that a data sector is reassigned to a new LBA. Instead, the present invention updates only a portion of the CRC check bytes that are effected by the new LBA.

[0013] The present invention performs an exclusive OR (XOR) function on the old LBA and the new reassigned LBA for a data sector. Galois Field multiplication is then performed on the result of the XOR function to generate an output that indicates the contribution of the new LBA to the CRC bytes. The present invention then performs an XOR function on the old CRC bytes and the output of the Galois Field multiplication to generate new CRC bytes. The new CRC bytes can be used by a CRC engine to protect from errors in the data bytes after the data bytes have been assigned to the new LBA sector.

[0014] The techniques of the present invention protect the integrity of the data bytes by updating the CRC bytes to reflect the LBA of the reassigned sector. The techniques of the present invention are also faster than recalculating all of the CRC bytes, because only a portion of the CRC bytes are updated to reflect the reassigned LBA. These techniques save processing time and resources.

[0015] The techniques of the present invention do not use the data bytes stored in DRAM to recalculate the CRC bytes, so that corrupted data introduced into the data bytes by the DRAM does not effect the new updated CRC bytes. Therefore, the techniques of the present invention are less susceptible to generating errors in the new CRC bytes.

[0016] Other objects, features, and advantages of the present invention will become apparent upon consideration of the following detailed description and the accompanying drawings, in which like reference designations represent like features throughout the figures.

[0022] FIG. 1 illustrates a data sector 100. Data sector 100 is a format for storing data onto a data storage medium such as a magnetic hard disk. The data sector 100 includes a group of data bytes (e.g., 512 data bytes), and a logical block address (LBA). The LBA corresponds to the location that the data sector 100 is stored on the disk. The LBA is typically not stored on the disk. Sector 100 also includes CRC and ECC bytes that are used to detect and correct errors in the data bytes.

[0023] The present invention applies to many types of data storage systems and media such as optical and magnetic hard disks and disk drives. Magnetic hard disk drives are discussed herein for illustrative purposes only and are not intended to limit the scope of the present invention.

[0024] FIG. 2 illustrates a process for updating cyclic redundancy check (CRC) bytes for data sectors that have been reassigned to a new logical block address (LBA) according to an embodiment of the present invention. FIG. 3 illustrates a block diagram of a hardware system for updating CRC bytes for data sectors that have been reassigned to a new LBA according to an embodiment of the present invention.

[0025] FIG. 4 illustrates a block diagram of an error correction system 401 according to an embodiment of the present invention. Data correction system 401 includes a drive interface 402, an ECC and CRC generation engine for disk operations 403, a CRC generation and check engine for host operations 404, and a host interface 405. Engines 403 and 404 communicate with DRAM storage device 307 as shown in FIG. 4. Host interface 405 interfaces with a host data storage system. Drive interface 402 transmits data to and from a disk or other data storage medium.

[0026] ECC/CRC generation engine 404 calculates CRC bytes for each sector of data bytes using the original LBA values as soon as host interface 405 receives the data bytes from the host. The CRC bytes are calculated immediately to protect the data from being corrupted, and then the CRC bytes are stored temporality in DRAM buffer 307.

[0027] As discussed above, when a host system attempts to store data bytes in a sector on a disk that contains a defect, the disk system reassigns the data bytes to a new sector that has a new LBA. When the disk drive system reassigns a set of data bytes to a new sector with a new LBA, the CRC bytes can no longer accurately protect the data bytes, because the CRC bytes were calculated based on the old LBA.

[0028] When data bytes are reassigned to a new sector, the system of FIG. 3 updates the portion of the CRC bytes that are based on the LBA of the old sector so that the CRC bytes are based on the reassigned LBA value. When the CRC bytes are based on the reassigned LBA value, the CRC engine can use these CRC bytes to accurately detect errors in the data bytes within the corresponding sector.

[0029] At step 201 in FIG. 2, an exclusive OR (XOR) gate 301 performs an XOR Boolean function on the “old LBA” for the sector that has the defect and the reassigned “new LBA.” The XOR function performed at step 201 is also referred to as a modular 2 addition function. XOR gate 301 compares the old and new LBA bytes and identifies which bits are different between these two sets of LBA bytes. The output bytes of XOR gate 301 indicate the difference between the old LBA bytes and the new LBA bytes.

[0030] At step 202, circuitry in block 302 performs a Galois Field multiplication function on the output bytes of XOR gate 301. Galois Field multiplication is an algorithm that is well known to those of skill in the data byte error correction art. Galois Field multiplication is an algorithm performed by CRC engines 403 and 404 to generate the CRC bytes based on the data bytes and the LBA. According to the present invention, the process of FIG. 2 recalculates only the portion of the CRC bytes that are based on the LBA bytes.

[0031] At step 202, the Galois Field multiplication function is performed by multiplying each byte from XOR gate 301 by a corresponding location constant. The location constants depend on the size of the sector. The results of these multiplications are added together using modular 2 addition (i.e., the XOR function) according to Galois Field multiplication. The output of block 302 indicates the changes to the components of the CRC bytes that are effected by reassigning the data to a new sector that has a different LBA.

[0032] A specific example of the Galois Field multiplication process performed at step 202 is now discussed in detail. Each LBA can contain 4 bytes and 32 bits. The output result generated at step 201 also contains 4 bytes. The Galois Field function then multiplies each of the four bytes by corresponding location constants that represent the location of the byte in the sector and adds the results together using modular 2 addition (XOR). This calculation is performed for Galois Field a values to generate the output bytes of step 202.

[0033] Equations are shown below that implement the Galois Field multiplication on example values according to an embodiment of the present invention.
Result3=Mul(byte3, k2) XOR Mul(byte2, k3) XOR Mul(byte1, k4) XOR Mul(byte0, k5)
Result2=Mul(byte3, l2) XOR Mul(byte2, l3) XOR Mul(byte1, l4) XOR Mul(byte0, l5)
Result1=Mul(byte3, m2) XOR Mul(byte2, m3) XOR Mul(byte1, m4) XOR Mul(byte0, m5)
Result0=Mul(byte3, n2) XOR Mul(byte2, n3) XOR Mul(byte1, n4) XOR Mul(byte0, n5)

[0034] According to the above example, XOR gate 301 generates a 4 byte output value. These 4 bytes are identified as byte3, byte2, byte1, and byte0, respectively, in the equations above. The values k2-k5, l2-l5, m2-m5, and n2-n5 are the location constants. These constants are Galois Field constants that depend on the size of the sector. Example values of these location constants are shown in Table 1 below.

[0035]

TABLE 1
Constant	Alpha Value	Value in Hexadecimal
k2	(α5)516	60
k3	(α5)515	03
k4	(α5)514	b4
k5	(α5)513	26
l2	(α6)516	25
l3	(α6)515	60
l4	(α6)514	8f
l5	(α6)513	2d
m2	(α7)516	b5
m3	(α7)515	9c
m4	(α7)514	18
m5	(α7)513	75
n2	(α8)516	46
n3	(α8)515	6a
n4	(α8)514	9d
n5	(α8)513	8f

[0036] The function ‘Mul’ in the above equations is a well known multiplication function in Galois Field that involves adding the exponents of the α operands. This multiplication function multiplies byte3, byte2, byte1, and byte0 by the constants in Table 1 as shown in the equations above. The results of these multiplication functions are then added together using the XOR function as shown in the above equations to generate four resulting bytes: result3, result2, result1, and result0. The output of block 302 is a four byte value that equals result3, result2, result1, result0. The output of block 302 represents the contribution of the new reassigned LBA to the CRC bytes.

[0037] At step 203, the error correction system reads the old CRC bytes that are stored in the buffer memory 307. This step is performed by the DRAM read logic 306 in FIG. 3. The CRC engine calculated the old CRC bytes based on the LBA for the old sector before the data was reassigned to the new sector. The old CRC bytes are stored in DRAM 307. DRAM read logic 306 reads the old CRC bytes from DRAM 307 and provides these CRC bytes to an input of XOR gate 303.

[0038] At step 204, XOR gate 303 performs an XOR Boolean function on the old CRC bytes from read logic 306 and the bytes generated by Galois Field multiplier 302. The XOR function performed by gate 303 incorporates the contribution of the new reassigned LBA generated by block 302 into the old CRC bytes. The output signals of XOR gate 303 are the new updated CRC bytes. These new CRC bytes are based on the new reassigned LBA value.

[0039] DRAM write logic 304 writes the new CRC bytes to DRAM buffer 307 for the new data sector at step 205. The new CRC bytes can be used by the CRC engines 403 and 404 to detect errors in the data bytes after the data bytes have been assigned to the new LBA sector.

[0040] FIG. 5 illustrates graphically in box 501 that the old LBA bytes, data bytes, and CRC bytes can be XOR'ed with the LBA difference bytes, all zeroes, and the CRC update bytes generated by block 302, respectively. The data bytes are XORed to all zeroes so that the data bytes are not changed. By XORing the CRC update bytes to the old CRC bytes, only the updated bytes are changed in the old CRC bytes to produce the new CRC bytes in sector 502.

[0041] The techniques of the present invention protect the integrity of the data bytes by updating the CRC bytes to reflect the new LBA of the reassigned sector. The techniques of the present invention are faster than recalculating all of the CRC bytes, because only the portion of the CRC bytes that are effected by the new LBA are updated.

[0042] The techniques of the present invention do not use the data bytes stored in DRAM to recalculate the CRC bytes, so that errors introduced into the data bytes by the DRAM do not effect the new CRC bytes. Therefore, the techniques of the present invention are less susceptible to generating errors in the new CRC bytes.

[0043] While the present invention has been described herein with reference to particular embodiments thereof, a latitude of modification, various changes, and substitutions are intended in the present invention. In some instances, features of the invention can be employed without a corresponding use of other features, without departing from the scope of the invention as set forth. Therefore, many modifications may be made to adapt a particular configuration or method disclosed, without departing from the essential scope and spirit of the present invention. It is intended that the invention not be limited to the particular embodiments disclosed, but that the invention will include all embodiments and equivalents falling within the scope of the claims.