# Patent

## Title
Techniques for performing reduced complexity galois field arithmetic for correcting errors

## Abstract

Techniques are provided for performing Galois field arithmetic to detect errors in digital data stored on disks. Two 12-bit numbers or two 10-bit numbers are multiplied together in Galois field using tower arithmetic. In the 12-bit embodiment, a base field GF(2) is first extended to GF(23), GF(23) is extended to a first quadratic extension GF(26), and GF(26) is extended to a second quadratic extension GF(212). In the 10-bit embodiment, the base field GF(2) is first extended to GF(25), and GF(25) is extended to a quadratic extension GF(210). Each of the extensions for the 10-bit and 12-bit embodiments is performed using an irreducible polynomial. All of the polynomials used to generate the first and the second quadratic extensions of the Galois field are in the form x2+x+K, where K is an element of the ground field whose absolute trace equals 1.

## Background
BACKGROUND OF THE INVENTION
The present invention relates to techniques for performing reduced complexity Galois field arithmetic for correcting errors, and more particularly, to techniques for performing Galois field arithmetic using tower arithmetic that provides reduced complexity and reduced computational latency.
Errors in digital signals can be generated before the digital signals are stored on a data storage disk. Therefore, disk drives typically have error correction encoders. A Reed-Solomon (RS) encoder is one type of error correction encoder. An RS encoder generates error correction code (ECC) check bytes and cyclic redundancy check (CRC) bytes.
The ECC and CRC check bytes are used to detect errors and to correct errors in the data bytes using well known encoding processes. The RS encoder inserts ECC and CRC check bytes into the data stream before the data is written onto a disk. After data is read from the disk, an RS decoder uses the ECC and CRC check bytes to detect and correct errors in the data. Encoding and decoding of error correction codes is performed using arithmetical theories relating to Galois fields.
Many techniques for performing Galois field arithmetic in the context of error correction have been disclosed. For example, one prior art technique described in U.S. Pat. No. 5,502,665 relates to a method for performing Galois field multiplication. This technique requires a high degree of hardware complexity and requires a significant amount of computational latency. As a result, there is a need for performing Galois field arithmetic in a way that requires less hardware complexity and that has less computational latency.
BRIEF SUMMARY OF THE INVENTION
The present invention provides techniques for performing Galois field arithmetic to detect errors in digital data stored on disks and other data storage media. According to embodiments of the present invention, two 12-bit numbers or two 10-bit numbers are multiplied together in Galois field using tower arithmetic.
In the 12-bit embodiment, a base field GF(2) is first extended to GF(23), GF(23) is extended to a first quadratic extension GF(26), and GF(26) is extended to a second quadratic extension GF(212). Each of the extensions for the 12-bit embodiment is performed using an irreducible primitive polynomial. For the 12-bit embodiment, there are two irreducible polynomials (x3+x+1 and x3+x2+1) that generate GF(23).
In the 10-bit embodiment, the base field GF(2) is first extended to GF(25), and GF(25) is extended to a quadratic extension GF(210). Each of the extensions for the 10-bit embodiment is performed using an irreducible primitive polynomial. For the 10-bit embodiment, there are 6 irreducible primitive polynomials that generate GF(25). This list of 6 polynomials includes x5+x2+1; x5+x3+1; x5+x3+x2+x+1; x5+x4+x2+x+1; x5+x4+x3+x+1; and x5+x4+x3+x2+1.
All of the polynomials used to generate the first and the second quadratic extensions of the Galois field are in the form x2+x+K. The absolute trace of all the elements of the ground field can be calculated over GF(2). The values of the absolute trace can be 0 or 1. K is an element of the ground field whose absolute trace equals 1.
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.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1A is a block diagram detailing the architecture of a buffered hard disk drive controller that includes an on-the-fly error correction code (ECC) system for implementing on-the-fly error correction code.
FIG. 1B is a block diagram of a data storage system depicting data flow along a read channel and a write channel of the hard disk drive controller of FIG. 1A.
FIG. 2 illustrates a high level diagram of a 12×12 bit Galois field multiplier according to an embodiment of the present invention.
FIG. 3 illustrates a specific example of a 12×12 Galois field multiplier according to an embodiment of the present invention.
FIGS. 4A-4C illustrate examples of the three 3×3 multipliers shown in FIG. 3, according to embodiments of the present invention.
FIGS. 5A-5C illustrate an example of the 3×3 multipliers shown in FIGS. 4A-4C, according to embodiments of the present invention.
FIG. 6 illustrates four 3×3 multipliers that are an alternative to the multiplier of FIG. 4A, according to an embodiment of the present invention.
FIG. 7 illustrates an example of the combiner block shown in FIG. 3, according to an embodiment of the present invention.
FIG. 8 illustrates a 10×10 bit Galois field multiplier according to another embodiment of the present invention.
FIGS. 9A-9E illustrate logic gates that together are an embodiment of one of the 5×5 multipliers shown in FIG. 8.



DETAILED DESCRIPTION OF THE INVENTION
FIGS. 1A and 1B illustrate an example of a hard disk drive control system for reading and writing data onto a magnetic hard disk. The hard disk drive control system of FIGS. 1A-1B is an example of hard disk drive system that can implement techniques of the present invention. The hard disk drive system of FIGS. 1A-1B can detect and correct errors in the data read from a disk.
FIG. 1A illustrates an exemplary architecture of a buffered hard disk drive controller 50. Hard disk drive controller 50 is configured to read data from and write data to a magnetic hard disk 14. Controller 50 includes an on-the-fly error correction code (ECC) system 100 for implementing an on-the-fly error correction code. On-the-fly error correction code system 100 includes an ECC read processor 163 and an ECC write processor 167.
FIG. 1B is a block diagram of the hard disk drive controller 50 of FIG. 1A that includes an on-the-fly error correction code system 100. When sequences of digital binary data are to be written onto the disk 14, they are placed temporarily in a buffer 165 shown in FIG. 1A and subsequently processed and transduced along a write path or channel (167, 169, and 157).
The hard disk drive controller 50 includes a logic drive circuit 105 shown in FIG. 1B that formats data from hard disk assembly 33, for example from 8 bits to 32 bits. A disk assembly 33 is comprised of disk 14 and a head stack assembly including a spindle motor. A FIFO register 110 stores the formatted data and exchanges the same with a sector buffer 120. The ECC system 100 receives the formatted data from the drive logic circuit 105 and performs an error correction coding algorithm. ECC system 100 can also perform the techniques and processes of the present invention, which are discussed in detail below.
A buffer manager 115 controls data traffic between the ECC system 100, a sector buffer (i.e., random access memory) 120, and a microprocessor 125. Another FIFO register 130 stores data and exchanges the same with the sector buffer 120. A sequence controller 135 is connected between the drive logic circuit 105, the microprocessor 125, and a host interface 140, to control the sequence operation of the data traffic and various commands across the hard drive controller 50. The host interface 140 provides an interface between the hard drive controller 50 and a host 60.
First, a predetermined number of binary data elements, also termed bytes, in a data string are moved from the buffer 165 and streamed through an ECC write processor 167. In the ECC write processor 167, the data bytes are mapped into codewords drawn from a suitable linear block or cyclic code such as a Reed-Solomon code. Next, each codeword is mapped in a write path signal-shaping unit 169 into a run length limited or other bandpass or spectral-shaping code and changed into a time-varying signal. The time-varying signal is applied through an interface read/write transducer interface 157 and then to the write element in a magneto resistive (or other suitable transducer head) for conversion into magnetic flux patterns.
All of the measures starting from the movement of the binary data elements from buffer 165 until the magnetic flux patterns are written on a selected disk track as the rotating disk 14 passes under the read/write head are synchronous and streamed. For purposes of efficient data transfer, the data is de-staged (written out) or staged (read) a codeword at a time.
Thus, both the mapping of binary data into Reed-Solomon codewords and the conversion to flux producing time-varying signals must be done well within the time interval defining a unit of recording track length moving under the transducer. Typical units of recording track length are equal fixed-length byte codewords of 512 bytes.
When sequences of magnetic flux patterns are to be read from the disk 14, they are processed in a read path or channel (157, 159, 161, and 163) and written into the buffer 165. The time-varying signals sensed by a transducer are passed through the read/write transducer interface 157 to a digital signal extraction unit 159. Here, the signal is detected and a decision is made as to whether it should be resolved as a binary 1 or 0. As these 1's and 0's stream out of the signal extraction unit 159, they are arranged into codewords in the formatting unit 161.
Because the read path is evaluating sequences of Reed-Solomon codewords previously recorded on the disk 14, absent error or erasure, the codewords should be the same. In order to test whether that is the case, each codeword is applied to an ECC read processor 163 over a path from a formatter 161.
Also, the output from the ECC processor 163 is written into buffer 165. The read path also operates in a synchronous data-streaming manner such that any detected errors must be located and corrected within the codeword well in time for the ECC read processor 163 to receive the next codeword read from the disk track. The buffer 165 and the read and write channels may be monitored and controlled by the microprocessor 125 to ensure efficacy where patterns of referencing may dictate that a path not be taken down, such as sequential read referencing.
As discussed above, Galois field arithmetic is performed by disk drive controllers to calculate the location of errors in digital data using error correction check bytes. The present invention provides techniques for performing Galois field arithmetic that require less hardware complexity and have less computational latency than many prior art techniques. Embodiments of the present invention will now be discussed in detail.
A Galois field GF(2m) is a set that contains a finite number of elements, where m is a positive integer. According to embodiments of the present invention, two 12-bit numbers or two 10-bit numbers are multiplied together in Galois field to generate a result. The result can be used to calculate error detection values or for other applications.
According to the present invention, Galois field arithmetic is performed using tower arithmetic. Tower arithmetic involves generating the Galois field using irreducible quadratic polynomials. An irreducible polynomial is a Galois field polynomial that does not factor in the ground field. In other words, the polynomial's roots are not in the ground field.
Both the 10-bit and the 12-bit embodiments begin with a base Galois field GF(2). In the 12-bit embodiment, the base field GF(2) is first extended to GF(23) using an irreducible polynomial. GF(23) is extended to a first quadratic extension GF(26) using an irreducible polynomial. GF(26) is extended to a second quadratic extension GF(22) using a irreducible polynomial. The three extensions are represented as GF(2)-GF(23)-GF(26)-GF(212).
In the 10-bit embodiment, the base field GF(2) is first extended to GF(25) using an irreducible polynomial. GF(25) is extended to a quadratic extension GF(210) using an irreducible polynomial. The two extensions are represented as GF(2)-GF(25)-GF(210).
According to the present invention, all of the polynomials used to generate the first and the second quadratic extensions of the Galois field are in the form, x2+x+K, where K is an element in the ground field whose absolute trace equals 1. Given a ground field, the absolute trace of all its elements can be calculated over GF(2). The values can be 0 or 1. Any element K whose absolute trace=1 can be used in x2+x+K.
A finite extension F=qm of the finite field K=q is a vector space over K. F has dimension m over K, and {α1, . . . , αm) is a basis of F over K. For αεF=qm and F=q, the trace of TrF/K(α) over K is defined by equation (1).

TrF/K(α)=α+αq+ . . . +αqm−1  (1)

If K is the prime subfield of F, then TrF/K(α) is called the absolute trace of α and simply denoted by TrF(α). In other words, the trace of α over K is the sum of the conjugates of α with respect to K.
In the 12-bit embodiment, there are 2 irreducible primitive polynomials that generate GF(23). This list of 2 polynomials includes x3+x+1 and x3+x2+1.
Thus, the Galois field GF(23) can be generated from GF(2) using a generator “a” that is a root of a3+a+1=0. The first quadratic extension GF(26) is calculated as follows. There are 4 GF(26) generators over GF(23) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 6}=[1, 0, 0, 1, 0, 1, 1]. There are 4 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 4 irreducible quadratic polynomials defined in GF(23) that are shown in Table 1.









TABLE 1









b2 + b + 1



b2 + b + a3



b2 + b + a5



b2 + b + a6










The second quadratic extension GF(212) is calculated as follows. There are 32 GF(212) generators over GF(26) that correspond to all of the polynomials c2+c+bi, where the trace(trace(bi))=1. The values for bi are selected from the list of {trace(trace(bi), i=0, . . . , 62}=[0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0]. There are 32 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power bi to produce 32 polynomials generators shown in Table 2.












TABLE 2









c2 + c + b
c2 + c + b15
c2 + c + b26
c2 + c + b41



c2 + c + b2
c2 + c + b16
c2 + c + b30
c2 + c + b42



c2 + c + b4
c2 + c + b17
c2 + c + b32
c2 + c + b44



c2 + c + b5
c2 + c + b19
c2 + c + b34
c2 + c + b50



c2 + c + b8
c2 + c + b20
c2 + c + b37
c2 + c + b51



c2 + c + b10
c2 + c + b21
c2 + c + b38
c2 + c + b52



c2 + c + b11
c2 + c + b22
c2 + c + b39
c2 + c + b57



c2 + c + b13
c2 + c + b25
c2 + c + b40
c2 + c + b60










In the 12-bit embodiment, the Galois field GF(23) can also be generated from GF(2) using a generator “A” that is a root of A3+A2+1=0. The first quadratic extension GF(26) is calculated as follows. There are 4 GF(26) generators over GF(23) that correspond to all of the polynomials B2+B+Ai, where trace(Ai)=1. The values for Ai are selected from the list of {trace(Ai), i=0, . . . , 6}=[1, 1, 1, 0, 1, 0, 0]. There are 4 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power Ai to generate a list of 4 irreducible quadratic polynomials defined in GF(23) as shown in Table 3.









TABLE 3









B2 + B + 1



B2 + B + A



B2 + B + A2



B2 + B + A4










The second quadratic extension GF(212) is calculated as follows. There are 32 GF(212) generators over GF(26) that correspond to all of the polynomials C2+C+Bi, where the trace(trace Bi))=1. The values for Bi are selected from the list of {trace(trace(Bi), i=0, . . . , 62}=[0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0]. There are 32 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power Bi to produce 32 polynomial generators shown in Table 4.










TABLE 4







C2 + C + B
C2 + C + B15
C2 + C + B26
C2 + C + B41


C2 + C + B2
C2 + C + B16
C2 + C + B30
C2 + C + B42


C2 + C + B4
C2 + C + B17
C2 + C + B32
C2 + C + B44


C2 + C + B5
C2 + C + B19
C2 + C + B34
C2 + C + B50


C2 + C + B8
C2 + C + B20
C2 + C + B37
C2 + C + B51


C2 + C + B10
C2 + C + B21
C2 + C + B38
C2 + C + B52


C2 + C + B11
C2 + C + B22
C2 + C + B39
C2 + C + B57


C2 + C + B13
C2 + C + B25
C2 + C + B40
C2 + C + B60









In the 10-bit embodiment, the base field GF(2) is first extended to GF(25) using an irreducible primitive polynomial. GF(25) is then extended to a quadratic extension GF(210) using an irreducible primitive polynomial.
In the 10-bit embodiment, there are 6 irreducible primitive polynomials that generate GF(25). This list of 6 polynomials includes x5+x2+1; x5+x3+1; x5+x3+x2+x+1; x5+x4+x2+x+1; x5+x4+x3+x+1; and x5+x4+x3+x2+1.
Thus, the Galois field GF(25) can be generated from GF(2) using a generator “a” that is a root of a5+a2+1=0. The quadratic extension GF(210) is calculated as follows. There are 16 GF(210) generators over GF(25) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 30}=[1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0]. There are 16 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 16 irreducible quadratic polynomials defined in GF(210) that are shown in Table 5.












TABLE 5









b2 + b + 1
b2 + b + a9
b2 + b + a13
b2 + b + a21



b2 + b + a3
b2 + b + a10
b2 + b + a17
b2 + b + a22



b2 + b + a5
b2 + b + a11
b2 + b + a18
b2 + b + a24



b2 + b + a6
b2 + b + a12
b2 + b + a20
b2 + b + a26










The Galois field GF(25) can also be generated from GF(2) using a generator “a” that is a root of a5+a3+1=0. The quadratic extension GF(210) is calculated as follows. There are 16 GF(210) generators over GF(25) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 30}=[1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0]. There are 16 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 16 irreducible quadratic polynomials defined in GF(210) that are shown in Table 6.












TABLE 6









b2 + b + 1
b2 + b + a10
b2 + b + a18
b2 + b + a22



b2 + b + a5
b2 + b + a11
b2 + b + a19
b2 + b + a25



b2 + b + a7
b2 + b + a13
b2 + b + a20
b2 + b + a26



b2 + b + a9
b2 + b + a14
b2 + b + a21
b2 + b + a28










The Galois field GF(25) can also be generated from GF(2) using a generator “a” that is a root of a5+a3+a2+a+1=0. The quadratic extension GF(210) is calculated as follows. There are 16 GF(210) generators over GF(25) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 30}=[1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1]. There are 16 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 16 irreducible quadratic polynomials defined in GF(210) that are shown in Table 7.












TABLE 7









b2 + b + 1
b2 + b + a12
b2 + b + a19
b2 + b + a27



b2 + b + a3
b2 + b + a14
b2 + b + a23
b2 + b + a28



b2 + b + a6
b2 + b + a15
b2 + b + a24
b2 + b + a29



b2 + b + a7
b2 + b + a17
b2 + b + a25
b2 + b + a30










The Galois field GF(25) can also be generated from GF(2) using a generator “a” that is a root of a5+a4+a2+a+1=0. The quadratic extension GF(210) is calculated as follows. There are 16 GF(210) generators over GF(25) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 30}=[1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1]. There are 16 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 16 irreducible quadratic polynomials defined in GF(210) that are shown in Table 8.












TABLE 8









b2 + b + 1
b2 + b + a8
b2 + b + a16
b2 + b + a26



b2 + b + a
b2 + b + a11
b2 + b + a21
b2 + b + a27



b2 + b + a2
b2 + b + a13
b2 + b + a22
b2 + b + a29



b2 + b + a4
b2 + b + a15
b2 + b + a23
b2 + b + a30










The Galois field GF(25) can also be generated from GF(2) using a generator “a” that is a root of a5+a4+a3+a+1=0. The quadratic extension GF(210) is calculated as follows. There are 16 GF(210) generators over GF(25) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 30}=[1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1]. There are 16 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 16 irreducible quadratic polynomials defined in GF(210) that are shown in Table 9.












TABLE 9









b2 + b + 1
b2 + b + a5
b2 + b + a15
b2 + b + a23



b2 + b + a
b2 + b + a8
b2 + b + a16
b2 + b + a27



b2 + b + a2
b2 + b + a9
b2 + b + a18
b2 + b + a29



b2 + b + a4
b2 + b + a10
b2 + b + a20
b2 + b + a30










The Galois field GF(25) can also be generated from GF(2) using a generator “a” that is a root of a5+a4+a3+a2+1=0. The quadratic extension GF(210) is calculated as follows. There are 16 GF(210) generators over GF(25) that correspond to all of the polynomials b2+b+ai, where trace(ai)=1. The values for ai are selected from the list of {trace(ai), i=0, . . . , 30}=[1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0]. There are 16 nonzero 1 values in this list. Each nonzero value in the list corresponds to a power ai to generate a list of 16 irreducible quadratic polynomials defined in GF(210) that are shown in Table 10.












TABLE 10









b2 + b + 1
b2 + b + a4
b2 + b + a12
b2 + b + a19



b2 + b + a
b2 + b + a6
b2 + b + a14
b2 + b + a24



b2 + b + a2
b2 + b + a7
b2 + b + a16
b2 + b + a25



b2 + b + a3
b2 + b + a8
b2 + b + a17
b2 + b + a28










The present invention includes techniques for performing Galois field multiplication to correct errors in data stored on disks and other data storage media. FIG. 2 is a high level diagram of a Galois field multiplier according to an embodiment of the present invention. Multiplier 200 multiplies a 12-bit number X by a 12-bit number Y to obtain a 12-bit result Z using Galois field. The multiplicand X includes 12 bits a0-a11. These 12 bits are represented by four sets of 3 bits, x3, x2, x1, and x0 as shown in FIG. 2. These four sets of bits can be grouped into two sets of 6 bits, X0=[x1, x0] and X1=[x3, x2].
The multiplier Y includes 12 bits b0-b11. These 12 bits are represented by four sets of 3 bits, y3, y2, y1, and y0 as shown in FIG. 2. These four sets of bits can be grouped into two sets of bits, Y0=[y1, y0] and Y1=[y3, y2]. Further details of how multiplier 200 performs Galois field multiplication according to the present invention are described below.
FIG. 3 illustrates a specific example of a Galois field multiplier 300 according to the present invention. Galois field multiplier 300 is a 12×12 multiplier. Galois field multiplier 300 multiplies 12-bit number X by 12-bit number Y. Galois field multiplier 300 includes three 3×3 multipliers 301-303 and a combiner block 310.
Multiplier 301 receives input bits x0, x1, y0, and y1, and generates A0 and B0. Multiplier 302 receives input bits x2, x3, y2, and y3, and generates A1 and B1. Multiplier 303 receives the results of x3⊕x1, x2⊕x0, y3⊕y1, and y2⊕y0 and generates output bits A2 and B2. A0, B0, A1, B1, A2, and B2 each have 3 bits. In the Figures, the symbol ⊕ indicates an XOR logic function.
Combiner block 310 receives bits A0, B0, A1, B1, A2, and B2 and generates 12 output bits O0, O1, O2, and O3 that represent the full result of the 12×12 Galois field multiplication. O0, O1, O2, and O3 each have 3 bits.
Further details of multiplier blocks 301-303 are now discussed. FIGS. 4A-4C illustrate examples of multiplier blocks 301-303, respectively, according to embodiments of the present invention. Multiplier 301 in FIG. 4A includes three 3×3 multipliers 401-403 and six exclusive OR (XOR) logic gates 441-443 and 451-453. Multiplier 401 multiplies x1 (3 bits) by y1 (3 bits) to generate a 3-bit result, g0, g1, g2. Multiplier 402 multiplies x0 (3 bits) by y0 (3 bits) to generate a 3-bit result, h0, h1, h2. Multiplier 403 multiplies the 3-bit result of y0⊕y1 by the 3-bit result of x0⊕x1 to generate a 3-bit result, j0, j1, j2.
XOR gates 441-443 perform 3 respective XOR functions on the 3-bit result of multiplier 401 (g0, g1, g2) and the 3-bit result of multiplier 402 (h0, h1, h2) to generate a 3-bit result B0, as shown in FIG. 4A. XOR gates 451-453 perform 3 respective XOR functions on the 3-bit result of multiplier 402 (h0, h1, h2) and the 3-bit result of multiplier 403 (j0, j1, j2) to generate a 3-bit result A0, as shown in FIG. 4A.
Multiplier 302 in FIG. 4B includes three 3×3 multipliers 411-413, a first set of 3 XOR gates represented by 461, and a second set of 3 XOR gates represented by 462. Multiplier 411 multiplies x3 (3 bits) by y3 (3 bits) to generate a 3-bit result. Multiplier 412 multiplies x2 (3 bits) by y2 (3 bits) to generate a 3-bit result. Multiplier 413 multiplies the 3-bit result of y2⊕y3 by the 3-bit result of x2⊕x3 to generate a 3-bit result.
XOR gates 461 perform respective exclusive OR functions on the 3-bit output of multiplier 411 and the 3-bit output of multiplier 412 to generate a 3-bit output B1. XOR gates 462 perform exclusive OR functions on the 3-bit output of multiplier 412 and the 3-bit output of multiplier 413 to generate a 3-bit output A1.
Multiplier 303 in FIG. 4C includes three 3×3 multipliers 421-423, a first set of three XOR gates represented by 471, and a second set of XOR gates represented by 472. Multiplier 421 multiplies the 3-bit result of y0⊕y2 by the 3-bit result of x0⊕x2 to generate a 3-bit result. Multiplier 422 multiplies the 3-bit result of x1⊕x3 by the 3-bit result of y1⊕y3 to generate a 3-bit result. Multiplier 423 multiplies the result of a first set of XOR functions (x0⊕x2)⊕(x1⊕x3) by the result of a second set of XOR functions (y0⊕y2)⊕(y1⊕y3) to generate a 3 bit result.
XOR gates 471 perform respective exclusive OR functions on the 3-bit output of multiplier 421 and the 3-bit output of multiplier 422 to generate a 3-bit output B2. XOR gates 472 perform exclusive OR functions on the 3-bit output of multiplier 422 and the 3-bit output of multiplier 423 to generate a 3-bit output A1.
Multipliers 500, 510, and 520 shown in FIGS. 5A-5C together are an embodiment of 3×3 multiplier 402 of FIG. 4A, according to an embodiment of the present invention. Multipliers 500, 510, and 520 together perform the function of multiplier 402 by multiplying x0 by y0, where x0=[a0, a1, a2], y0=[b0, b1, b2], and a0-a2 and b0-b2 represent 6 individual bits. According to further embodiments, multipliers 500, 510, and 520 can also be used to perform the multiplication functions of 3×3 multipliers 401 and 403 by arranging the input bits accordingly.
Referring to FIG. 5A, AND gate 501 is coupled to receive bits a0 and b2 as inputs. AND gate 502 is coupled to receive bits a1 and b1 as inputs. AND gate 503 is coupled to receive bit a2 and the result of b0⊕b2 as inputs. The outputs of AND gates 501-503 are coupled to inputs of XOR gate 504. XOR gate 504 generates output h2.
Referring to FIG. 5B, AND gate 511 is coupled to receive bits b1 and a0 as inputs. AND gate 512 is coupled to receive bit a1 and the result of b0⊕b2 as inputs. AND gate 513 is coupled to receive bit a2 and the result of b0⊕b1 as inputs. The outputs of AND gates 511-513 are coupled to inputs of XOR gate 514. XOR gate 514 generates output h1.
Referring to FIG. 5C, AND gate 521 is coupled to receive bits b2 and a2 as inputs. AND gate 522 is coupled to receive bits a1 and b0 as inputs. AND gate 523 is coupled to receive bits a0 and b1 as inputs. The outputs of AND gates 521-523 are coupled to inputs of XOR gate 524. XOR gate 524 generates output h2.
FIG. 6 illustrates a set of multipliers that are an alternative embodiment to multiplier 301 shown in FIG. 3. The embodiment of FIG. 6 includes 3×3 multiplier 601, 3×3 multiplier 602, 3×3 multiplier 603, and 3×3 multiplier 604. Multiplier 601 multiplies input bits x0 by y0. Multiplier 602 multiplies input bits x1 by y1. Multiplier 603 multiplies input bits x1 by y0. Multiplier 604 multiplies input bits x0 by y1. XOR gates 611 perform exclusive OR functions on the output bits of multipliers 601 and 602. XOR gates 612 perform exclusive OR functions on the output bits of multipliers 602-604.
The embodiment of FIG. 6 is faster (less computational latency) than multiplier 301 shown in FIG. 4A. In multiplier 301 of FIG. 4A, two XOR functions are performed on the input bits (y0⊕y1 and x0⊕x1), and the results of these XOR functions are inputted into multiplier 403. These extra XOR functions require additional computation time to perform. The embodiment of FIG. 6 does not require these extra XOR functions, and is faster as a result. However, the embodiment of FIG. 6 requires more logic gates, because it has an extra 3×3 multiplier 604. The extra multiplier 604 is performed in parallel with multipliers 601-603, and therefore, does not require additional computation time: The configuration of FIG. 6 can also be used as an alternative embodiment to multipliers 302 and 303 by rearranging the input bits accordingly.
FIG. 7 illustrates an embodiment of combiner block 310 shown in FIG. 3. Combiner block 310 combines the output bits A0-A2 and B0-B2 of multipliers 301-303 to generate the final output bits O0-O3. Combiner block 310 includes four XOR gates 701-704. XOR gate 701 receives input bits A0 and B0 and generates output bits O0. XOR gate 702 receives input bits A0, A1 and B1 and generates output bits O1. XOR gate 703 receives input bits B0 and B2 and generates output bits O2. XOR gate 704 receives input bits A0 and A2 and generates output bits O3.
FIG. 8 illustrates a 10-bit by 10-bit Galois field multiplier 800 according to another embodiment of the present invention. Galois field multiplier 800 multiplies a 10-bit number X by a 10-bit number Y, where X=[x1, x2] and Y=[y1, y2]. x1, x2, y0, and y1 each have 5 bits. 5×5 multiplier 801 multiplies x1 by y1. 5×5 multiplier 802 multiplies x0 by y0. 5×5 multiplier 803 multiplies the result of x0⊕x1 by the result of y0⊕y1. XOR gates 811 perform respective exclusive OR functions on the 5 output bits of multiplier 801 and the 5 output bits of multiplier 802 to generate 5 output bits P0-P4.
XOR gates 812 performs respective exclusive OR functions on the 5 output bits of multiplier 802 and the 5 output bits of multiplier 803 to generate 5 output bits P5-P9. The embodiment of FIG. 8 has reduced complexity and reduced computational latency relative to many prior art techniques.
FIGS. 9A-9E illustrate logic gates that together are an embodiment of 5×5 multiplier 802 in FIG. 8. The logic gates of FIGS. 9A-9E multiply x0=[a0, a1, a2, a3, a4] by y0=[b0, b1, b2, b3, b4], where a0-a4 and b0-b4 represent 10 bits. The logic gates of FIGS. 9A-9E can also be used to implement 5×5 multipliers 801 and 803 by reassigning the appropriate bits to the inputs of the logic gates.
Referring to FIG. 9A, AND gate 901 receives bits b0 and a4, AND gate 902 receives bit a4 and the result of b0⊕b3, AND gate 903 receives bits a4 and b3, AND gate 904 receives bits a3 and the result of b1⊕b4 and AND gate 905 receives bits a2 and b2. XOR gate 906 receives the outputs of AND gates 901 and 902, and XOR gate 907 receives the outputs of AND gates 903 and 904. XOR gate 908 receives the outputs of XOR gates 906-907 and AND gate 905. The output of XOR gate 908 is K4, the first output bit of multiplier 802.
Referring to FIG. 9B, AND gate 911 receives bits b3 and a0, AND gate 912 receives bit a2 and the result of b1⊕b4, AND gate 913 receives bits a1 and b2, AND gate 914 receives bits a3 and the result of b0⊕b3 and AND gate 915 receives bits a4 and the result of b4⊕b2. XOR gate 916 receives the outputs of AND gates 911 and 912, and XOR gate 917 receives the outputs of AND gates 913 and 914. XOR gate 918 receives the outputs of XOR gates 916-917 and AND gate 915. The output of XOR gate 918 is K3, the second output bit of multiplier 802.
Referring to FIG. 9C, AND gate 921 receives bits b2 and a0, AND gate 922 receives bit a1 and the result of b4⊕b1, AND gate 923 receives bit a2 and the result of b3⊕b0, AND gate 924 receives bits a3 and the result of b4⊕b2, and AND gate 925 receives bit a4 and the result of b4⊕b1⊕b3. XOR gate 926 receives the outputs of AND gates 921 and 922, and XOR gate 927 receives the outputs of AND gates 923 and 924. XOR gate 928 receives the outputs of XOR gates 926-927 and AND gate 925. The output of XOR gate 928 is K2, the third output bit of multiplier 802.
Referring to FIG. 9D, AND gate 931 receives bits b1 and a0, AND gate 932 receives bits a1 and b0, AND gate 933 receives bits a2 and b4, AND gate 934 receives bits a3 and b3, and AND gate 935 receives bits a4 and b2. XOR gate 936 receives the outputs of AND gates 931 and 932, and XOR gate 937 receives the outputs of AND gates 933 and 934. XOR gate 938 receives the outputs of XOR gates 936-937 and AND gate 935. The output of XOR gate 938 is K1, the fourth output bit of multiplier 802.
Referring to FIG. 9E, AND gate 941 receives bits b2 and a3, AND gate 942 receives bit a4 and the result of b4⊕b1, AND gate 943 receives bits a2 and b3, AND gate 944 receives bits a1 and b4, and AND gate 945 receives bit a0 and b0. XOR gate 946 receives the outputs of AND gates 941 and 942, and XOR gate 947 receives the outputs of AND gates 943 and 944. XOR gate 948 receives the outputs of XOR gates 946-947 and AND gate 945. The output of XOR gate 948 is K0, the fifth output bit of multiplier 802.
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 embodiment disclosed, but that the invention will include all embodiments and equivalents falling within the scope of the claims.

## Claims

1. An integrated circuit having a memory and a microprocessor that performs Galois field arithmetic on 12-bit numbers read from a digital data stored on a disk, the integrated circuit comprising:
an arithmetic unit operable by the microprocessor to extend for the 12-bit numbers a base field GF(2) to GF(23) using a polynomial a3+a+1 over the base field GF(2),
wherein the arithmetic unit is operable by the microprocessor to extend for the 12-bit numbers GF(23) to a first quadratic extension GF(26) using a polynomial b2+b+ai, and values for ai are selected from a first list comprising {trace(ai), i=0, . . . , 6}=[1, 0, 0, 1, 0, 1, 1] wherein trace(ai) =1, and
wherein the arithmetic unit is operable by the microprocessor to extend for the 12-bit numbers GF(26) to a second quadratic extension GF(212) using a polynomial c2+c+bi, and values for bi are selected from a second list comprising {trace(trace(bi), i=0, . . . , 62}=[0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0], wherein trace(trace(bi))=1;
wherein the values for ai and the first list produce a first set of irreducible polynomials, and the values for bi and the second list produce a second set of irreducible polynomials; and
wherein the first set of irreducible polynomials and the second set of irreducible polynomials are used to detect errors in digital data stored on a disk.

2. An integrated circuit having a memory and a microprocessor that performs Galois field arithmetic on 12-bit numbers read from a digital data stored on a disk, the integrated circuit comprising:
an arithmetic unit operable by the microprocessor to extend for the 12-bit numbers a base field GF(2) to GF(23) using a polynomial A3+A2+1 over the base field GF(2),
wherein the arithmetic unit is operable by the microprocessor to extend for the 12-bit numbers GF(23) to a first quadratic extension GF(26) using a polynomial B2+B+Ai, and values for Ai are selected from a first list comprising {trace(Ai), i=0, . . . , 6}=[1, 1, 1, 0, 1, 0, 0] where trace(Ai)=1, and
wherein the arithmetic unit is operable by the microprocessor to extend for the 12-bit numbers GF(26) to a second quadratic extension GF(212) using a polynomial C2+C +Bi, and values for Bi are selected from a second list comprising {trace(trace(Bi), i =0, . . . ,62}=[0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0], wherein trace(trace(Bi))=1;
wherein the values for Ai and the first list produce a first set of irreducible polynomials, and the values for Bi and the second list produce a second set of irreducible polynomials; and
wherein the first set of irreducible polynomials and the second set of irreducible polynomials are used to detect errors in digital data stored on a disk.

3. An integrated circuit having a memory and a microprocessor that performs Galois field arithmetic on 10-bit numbers read from a digital data stored on a disk, the integrated circuit comprising:
an arithmetic unit operable by the microprocessor to extend for the 10-bit numbers a base field GF(2) to GF(25) using an irreducible polynomial over the base field GF(2),
wherein the arithmetic unit is operable by the microprocessor to extend for the 10-bit numbers GF(25) to a quadratic extension GF(210) using a polynomial b2+b+ai, and values for ai are selected from a list wherein trace(ai)=1;
wherein the irreducible polynomial is a5+a2+1, and the values for ai in the list correspond to {trace(ai), i=0, . . . , 30}=[1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0] wherein trace(ai)=1;
wherein the values for ai and the list produce a set of irreducible polynomials used to detect errors in digital data stored on a disk.

4. The integrated circuit according to claim 3 wherein the irreducible polynomial is a5+a3+1, and the values for ai in the list correspond to {trace(ai), i=0, . . . , 30}=[1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0] Wherein trace(ai)=1.

5. The integrated circuit according to claim 3 wherein the irreducible polynomial is a5+a3+a2+a+1, and the values for ai in the list correspond to {trace(ai), i=0, . . . , 30}=[1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1] wherein trace(ai)=1.

6. The integrated circuit according to claim 3 wherein the irreducible polynomial is a5+a4+a2+a+1, and the values for ai in the list correspond to {trace(ai), i=0, . . . , 30}=[1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1] wherein trace(ai)=1.

7. The integrated circuit according to claim 3 wherein the irreducible polynomial is a5+a4+a3+a+1, and the values for ai in the list correspond to {trace(ai), i=0, . . . , 30}=[1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1] wherein trace(ai)=1.

8. The integrated circuit according to claim 3 wherein the irreducible polynomial is a5+a4+a3+a2+1, and the values for ai in the list correspond to {trace(ai), i=0, . . . , 30}=[1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0] wherein trace(ai)=1.