Search Images Maps Play YouTube News Gmail Drive More »
Sign in
Screen reader users: click this link for accessible mode. Accessible mode has the same essential features but works better with your reader.

Patents

  1. Advanced Patent Search
Publication numberUS4730321 A
Publication typeGrant
Application numberUS 06/869,005
Publication dateMar 8, 1988
Filing dateMay 30, 1986
Priority dateMay 30, 1986
Fee statusLapsed
Publication number06869005, 869005, US 4730321 A, US 4730321A, US-A-4730321, US4730321 A, US4730321A
InventorsMichael G. Machado
Original AssigneeQuantum Corporation
Export CitationBiBTeX, EndNote, RefMan
External Links: USPTO, USPTO Assignment, Espacenet
Disk drive with improved error correction code
US 4730321 A
Abstract
A rotating disk data storage subsystem is disclosed for recording and retrieving data in blocks of predetermined finite length, each block of data including an error correction code syndrome portion calculated in accordance with a predetermined Galois field error correction algorithm. The subsystem includes a data controller including a unitary, cyclic error correction code syndrome generator/decoder for processing each incoming byte of the block in accordance with the said error correction algorithm in a manner which tests for the presence of any errors and which generates error values from which the errors may be located and corrected. A microprocessor controller has access to the data controller for testing to determine if the generator has determined the presence of an error for an incoming block, and if so, for obtaining the error values. The microprocessor is programmed to process the error values to determine the location and nature of at least one error, and having access to the buffer memory whereby a data byte of the block including an error may be removed and a corrected byte substituted in its place.
Images(15)
Previous page
Next page
Claims(28)
I claim:
1. In Reed-Solomon error correction code apparatus for a computing system storage device including a programmed digital microcontroller for controlling operations of the device in accordance with prestored program routines and in which useful data written on the surface of a rotating disk in finite blocks is read by a transducing mechanism and in which each finite block of data so recorded includes finite field error correction coding syndrome information appended at the end thereof for enabling detection and correction of errors within the block, an error correction code syndrome generator/decoder of minimized logic elements for calculating error correction coding syndrome information in accordance with a predetermined Galois field and syndrome generator polynomial, the generator/decoder for testing the calculated information with the appended information to signal any discrepancies indicative of an error within the data block, the generator/decoder comprising:
an input/output summing junction for receiving each incoming data block as a clocked data stream of serial bytes,
an error correction code feedback path leading from the summing junction and carrying feedback values,
multiplier apparatus for multiplying the feedback values by a first predetermined constant to yield first product values, for multiplying the feedback values by a second predetermined constant to yield second product values, and for multiplying the feedback values by a third predetermined constant to yield third product values,
a first clocked latch stage for latching the feedback values present on the feedback path,
a first summing junction for summing the latched feedback values from the first latch stage with the first product values to yield first sum values,
a second clocked latch stage for latching the first sum values,
a second summing junction for summing the first sum values and the second product values to yield second sum values,
a third clocked latch stage for latching the second sum values,
a third summing junction for summing the second sum values and the third product values to yield third sum values,
a fourth clocked latch stage for latching the third sum values,
the input-output summing junction for summing the third sum values with the incoming clocked stream of serial bytes to generate the feedback values,
the first, second, third and fourth latch stages being clocked in synchronism with the incoming data stream of serial bytes,
testing means for testing the values held in the first, second, third and fourth latch stages at the end of processing of each block thereby to determine if an error has occurred, and
the first, second, third and fourth latch stages including at least one addressable, enablable bus driver for enabling syndrome byte values contained therein at the end of processing of a data block to be obtained and analyzed by the programmed digital microcontroller in accordance with Read Solomon error correction routines executed thereby for locating and correcting at least one data byte determined to be in error.
2. The error correction code syndrome generator/decoder set forth in claim 1 wherein each data block is divided into at least two interleaves, wherein the first, second, third and fourth latch stages include synchronously clocked byte serial latches corresponding in number to the number of interleaves, and wherein the syndrome generator/decoder calculates a number of syndromes corresponding in number to the number of interleaves.
3. The error correction code syndrome generator/decoder set forth in claim 2 wherein each data block is divided inside the generator/decoder into three interleaved parts, wherein each of the first, second, third and fourth latch stages includes three synchronously clocked serial latches, and wherein the syndrome generator/decoder calculates three syndromes, each syndrome corresponding to a said interleave.
4. The error correction code syndrome generator/decoder set forth in claim 3 wherein each data block includes five hundred twelve data bytes followed by twelve error correction code syndrome bytes, there being four syndrome bytes provided for each said interleave part.
5. The error correction code syndrome generator/decoder set forth in claim 4 wherein the first interleave begins with the first data byte and includes every third byte thereafter, the second interleave begins with the second data byte and includes every third byte thereafter, and the third interleave begins with the third byte and includes every third byte thereafter, and wherein the twelve syndrome bytes are appended immediately following the last data byte of the block in the order S3A, S1A, S2A, S3B, S1B, S2B, S3C, S1C, S2C, S3D, S1D, S2D, where S denotes syndrome byte, the numeral denotes the interleave number and the letters A, B, C and D denote respectively the first, second, third and fourth bytes of the syndrome.
6. The error correction code syndrome generator/decoder set forth in claim 1 wherein the Galois field is GF(28) in accordance with a field generator polynomial having the form of x8 +x4 +x3 +x2 +1, and wherein the first term of the field is x5 +x3 +x+1 (which is 00101011 binary).
7. The error correction code syndrome generator/decoder set forth in claim 6 wherein the syndrome byte values are generated in accordance with a syndrome generator polynomial having the form X4 +Alpha18 X3 +Alpha89 X2 +Alpha18 X+1.
8. In Reed-Solomon error correction code apparatus for a computing system storage device in which useful data written on the surface of a rotating disk in finite blocks is read by a transducing mechanism and in which each finite block of data so recorded includes finite field error correction coding syndrome information appended at the end thereof for enabling detection and correction of errors within the block, an error correction code syndrome generator of minimized logic elements for calculating error correction coding syndrome information in accordance with a Galois field GF(28) generated by a field generator polynomial having the form x8 +x4 +x3 +x2 +1 and wherein the first term of the field is x5 +x3 +x+1 (which is 00101011 binary), the generator for testing the calculated information with the appended information to signal any discrepancies indicative of an error within the data block, the generator comprising:
an input/output summing junction for receiving each incoming data block as a clocked data stream of serial bytes,
an error correction code feedback path leading from the summing junction and carrying feedback values,
multiplier apparatus for multiplying the feedback values by a first predetermined constant to yield first product values, for multiplying the feedback values by a second predetermined constant to yield second product values, and for multiplying the feedback values by a third predetermined constant to yield third product values,
a first clocked latch stage for latching the feedback values present on the feedback path,
a first summing junction for summing the latched feedback values from the first latch stage with the first product values to yield first sum values,
a second clocked latch stage for latching the first sum values,
a second summing junction for summing the first sum values and the second product values to yield second sum values,
a third clocked latch stage for latching the second sum values,
a third summing junction for summing the second sum values and the third product values to yield third sum values,
a fourth clocked latch stage for latching the third sum values,
the input-output summing junction for summing the third sum values with the incoming clocked stream of serial bytes to generate the feedback values,
the first, second, third and fourth latch stages being clocked in synchronism with the incoming data stream of serial bytes, and
testing means for testing the values held in the first, second, third and fourth latch stages at the end of processing of each block thereby to determine if an error has occurred.
9. The error correction code syndrome generator set forth in claim 8 wherein each data block is divided into at least two interleaves, wherein the first, second, third and fourth latch stages include synchronously clocked byte serial latches corresponding in number to the number of interleaves, and wherein the syndrome generator calculates a number of syndromes corresponding in number to the number of interleaves.
10. The error correction code syndrome generator set forth in claim 9 wherein each data block is divided inside the generator into three interleaved parts, wherein each of the first, second, third and fourth latch stages includes three synchronously clocked latches, and wherein the syndrome generator calculates three syndromes, each syndrome corresponding to a said interleave.
11. The error correction code syndrome generator set forth in claim 10 wherein each data block includes five hundred twelve data bytes followed by twelve error correction code syndrome bytes, there being four syndrome bytes provided for each said interleave part.
12. The error correction code syndrome generator set forth in claim 11 wherein the first interleave begins with the first data byte and includes every third byte thereafter, the second interleave begins with the second data byte and includes every third byte thereafter, and the third interleave begins with the third byte and includes every third byte thereafter, and wherein the twelve syndrome bytes are appended immediately following the last data byte of the block in the order S3A, S1A, S2A, S3B, S1B, S2B, S3C, S1C, S2C, S3D, S1D, S2D, where S denotes syndrome byte, the numeral denotes the interleave number and the letters A, B, C and D denote respectively the first, second, third and fourth bytes of the syndrome.
13. The error correction code syndrome generator set forth in claim 8 wherein the first syndrome byte values are generated in accordance with a syndrome generator polynomial having the form X4 +Alpha18 X3 +Alpha89 X2 +Alpha18 X+1.
14. The error correction code syndrome generator set forth in claim 8 wherein the first, second, third and fourth latch stages include at least one addressable, enablable bus driver for enabling syndrome values contained therein at the end of processing of a data block to be obtained and analyzed by a correction computer thereby for locating and correcting at least one data byte determined to be in error.
15. The error correction code generator set forth in claim 14 further comprising additional latching means for latching syndrome values of a present data block having an error so that a subsequent data block may be processed by said generator as the first block is undergoing error correction processing at the microprocessor.
16. A rotating disk data storage subsystem for storing useful data including a rotating disk having a storage surface in which the data is recorded in blocks of predetermined finite length, a positionable data transducer for reading the data of selected data blocks from the surface, a transducer actuator structure for moving the data transducer among data block locations available on the surface in response to data retrieval commands from a host system and for maintaining the data transducer accurately positioned at each data block location in response to servo information obtained from the data surface, a data controller for managing retrieval of data from the surface via the transducer, a buffer memory for temporarily storing each block of data retrieved from the surface, an interface communicating with the host for sending each data block and status commands to the host and for receiving operational commands from the host, a single microprocessor controller for controlling the actuator structure in order to position the transducer,
each block of data including an error correction code syndrome portion calculated in accordance with a predetermined Galois field error correction algorithm,
the data controller including a cyclic error correction code syndrome generator for processing each incoming byte of the block in accordance with the said error correction algorithm in a manner which tests for the presence of any errors and which generates error values from which the errors may be located and corrected,
the microprocessor having access to the data controller for testing to determine if the generator has determined the presence of an error for an incoming block, and if so, for obtaining the error values,
the microprocessor being programmed to process the error values to determine the location and nature of at least one error, and having access to the buffer memory whereby a data byte of the block including an error may be removed and a corrected byte substituted in its place.
17. The storage subsystem set forth in claim 16 wherein access by the microprocessor to the buffer memory is via registers of the data controller.
18. The data storage subsystem set forth in claim 16 wherein the Reed-Solomon error correction code syndrome generator comprises:
an input/output summing junction for receiving each incoming data block from the transducer as a clocked data stream of serial bytes,
an error correction code feedback path leading from the summing junction and carrying feedback values,
multiplier apparatus for multiplying the feedback values by a first predetermined constant to yield first product values for multiplying the feedback values by a second predetermined constant to yield second product values, and for multiplying the feedback values by a third predetermined constant to yield third product values,
a first clocked latch stage for latching the feedback values present on the feedback path,
a first summing junction for summing the latched feedback values from the first latch stage with the first product values to yield first sum values,
a second clocked latch stage for latching the first sum values,
a second summing junction for summing the first sum values and the second product values to yield second sum values,
a third clocked latch stage for latching the second sum values,
a third summing junction for summing the second sum values and the third product values to yield third sum values,
a fourth clocked latch stage for latching the third sum values,
the input-output summing junction for summing the third sum values with the incoming clocked stream of serial bytes to generate the feedback values,
the first, second, third and fourth latch stages being clocked in synchronism with the incoming data stream of serial bytes, and
testing means for enabling the microprocessor to test the values held in the first, second, third and fourth latch stages at the end of processing of each block thereby to determine if an error has occurred,
and wherein the microprocessor has direct access to the values held in the first, second, third and fourth latch stages at the end of processing of each block thereby to obtain the values therein.
19. The data storage subsystem set forth in claim 16 wherein each data block is divided into at least two interleaves, wherein the first, second, third and fourth latch stages include synchronously clocked byte serial latches corresponding in number to the number of interleaves, and wherein the syndrome generator calculates a number of syndromes corresponding in number to the number of interleaves.
20. The data storage subsystem set forth in claim 19 wherein each data block is divided inside the generator into three interleaved parts, wherein each of the first, second, thrid and fourth latch stages includes three synchronously clocked serial latches, and wherein the syndrome generator calculates three syndromes, each syndrome corresponding to a said interleave.
21. The data storage subsystem set forth in claim 20 wherein each data block includes five hundred twelve data bytes followed by twelve error correction code syndrome bytes, there being four syndrome bytes provided for each said interleave part.
22. The data storage subsystem set forth in claim 21 wherein the first interleave begins with the first data byte and includes every third byte thereafter, the second interleave begins with the second data byte and includes every third byte thereafter, and the third interleave begins with the third byte and includes every third byte thereafter, and wherein the twelve syndrome bytes are appended immediately following the last data byte of the block in the order S3A, S1A, S2A, S3B, S1B, S2B, S3C, S1C, S2C, S3D, S1D, S2D, where S denotes syndrome byte, the numeral denotes the interleave number and the letters A, B, C and D denote respectively the first, second, third and fourth bytes of the syndrome.
23. The data storage subsystem set forth in claim 16 wherein the error correction algorithm enables the error correction a field GF(28) to be generated by field generator polynomial having the form x8 +x4 +x3 +x2 +1 and wherein the first term of the field is of the form x5 +x3 +x+1 which is 00101011 in binary).
24. The data storage subsystem set forth in claim 23 wherein the syndrome byte values are generated by a syndrome generator polynomial having the form X4 +Alpha18 X3 +Alpha87 X2 +Alpha18 X+1.
25. The data storage subsystem set forth in claim 18 wherein the first, second, third and fourth latch stages include addressable, enablable bus drivers for enabling syndrome values contained therein at the end of processing of a data block to be obtained and analyzed by a correction computer thereby for locating and correcting at least one data byte determined to be in error.
26. The data storage subsystem set forth in claim 18 wherein a single bus driver is connected to the fourth latch stage output and a clocking circuit means responds to an addressing signal from the microprocessor controller in order to clock all of the latch stages, so that the microprocessor may thereby obtain all of the syndrome bytes in sequence.
27. The data storage subsystem set forth in claim 18 further comprising additional latch-drivers connected to the first, second, third and fourth latch stage outputs so that at least one subsequent block of data of a track may be checked for errors while error correction processing of a present data block of the track is being carried out.
28. The data storage subsystem set forth in claim 18 wherein the input-output, first, second and third summing junctions are implemented with two input exclusive-OR gates.
Description
FIELD OF THE INVENTION

The present invention relates to rotating disk data storage devices including improved and simplified apparatus and methods for automatic detection and correction of errors in blocks of data. More particularly, this invention relates to an error correction coding system which carries out a Reed-Solomon cyclic error correction code process on blocks of data to be stored in a rotating disk data storage device with simplified and minimized hardware logic.

BACKGROUND OF THE INVENTION

Since the advent of digital computing techniques thirty five years ago, attention has focused on methods for reducing errors in data. Such errors may be attributable to transient conditions in a computing apparatus or transmission channel, called "soft" errors; or they may be recurrent errors, such as those resulting from defects in data storage media, etc., called "hard" errors. In either event, in order to insure the integrity of data it has early recognized that errors must be located and corrected. For example, an error rate of 10-12 bits (i.e. one error bit in 1012 bits) is a typical performance specification for hard errors in a high capacity disk data storage subsystem.

Many different types of block and convolutional error detection and/or correction codes have been devised and have been applied to reduce error rates typically associated with different types of data paths and storage media. These codes are frequently named after the people who first devised or disclosed the particular code. For instance, such codes as Hamming codes, Fire codes, Golay code, Bose-Chaudhuri-Hocquenghem (BCH) codes, Reed-Solomon (RS) codes, and Goppa codes are known and used in the prior art and were introduced by the persons whose surnames have come to identify the particular code. The characteristics of these codes are summarized and explained in general terms in a recent article by Solomon W. Golomb entitled "Optical Disk Error Correction" appearing in Byte Magazine, Vol. 11, No. 5, May 1986, pages 203 to 210.

Rotating disk data storage devices typically store data as discrete blocks or frames, with each frame being related to a single data track or sector within a track. Commonly employed frame lengths are 256 (28), 512 (29) and 1024 (210) bytes. As a result of this characteristic of disk stores, one currently popular code for use in error correction processes associated therewith is the Reed-Solomon (RS) code method. This code treats m-bit bytes as individual code symbols. A single RS code word, or "frame" of data (including overhead associated with the error correction process) can be up to 2m -1 of m-bit bytes. If it is desired to correct any error that affects up to and no more than t bytes per frame, then the RS methodology requires that 2t bytes per frame be devoted to error correction redundancy or overhead. This leaves 2m -1-2t bytes available for useful data storage and retrieval.

While RS codes are becoming popular for error correction in disk stores, implementation of RS code methods has heretofore been very complicated and has required a considerable overhead of hardware devoted to carrying out the error correction process. One example of the complexity of hardware required for real time error correction with RS codes is U.S. Pat. No. 4,494,234 to Patel. In the prior approach described in the Patel patent, literally thousands of discrete logic circuit elements were required in order for the dedicated hardware apparatus to carry out error correction on the fly. A related Patel patent directed to the syndrome processing unit of the on the fly system patented by the referenced U.S. Pat. No. 4,494,234, is U.S. Pat. No. 4,504,948 which provides further useful background information relating to the processing required to correct errors based on Reed Solomon correction codes employing finite field theory. It, too, is extremely complicated and expensive, although effective for multi-byte error correction within the finite field data block.

One hitherto unsolved need has arisen for an effective RS error correction code system in which the special hardware requirements imposed by the process have been minimized.

One recognized phenomenon in rotating disk data storage devices is the tendency of data errors to cluster. An electrical transient condition, for example, may cause two or three adjacent bytes to become corrupted with errors. One known approach for minimizing the impact of cluster errors in error correction processing is to divide a data block into several subfields and to develop error syndromes based upon the interleave of the subfields. In this way, if error clusters occur, they will likely be spread over the several subfields. If each subfield of a particular block or sector is denominated an RS frame, the number of bytes t to be corrected for the frame may be made low, and the consequent error correction overhead (2t) per frame may also be kept low, while overall corrected error rates are extremely low. A need has arisen for RS error correction code apparatus which makes use of an interleave approach in order thereby to simplify and minimize the hardware required.

Since error correction is an occasional, as opposed to a constant, process, and the calculations required to perform RS error correction involve complex mathematics, a need has arisen to employ minimized logic to generate an error correction value or "syndrome" for each RS frame during data write operations, and to recover and check its "syndrome" during data read operations; and, to employ a general purpose digital microprocessor with a program subroutine for carrying out the intermittant and complex RS calculations necessitated when a detected non-zero syndrome reveals the presence of one or more errors in the RS frame.

SUMMARY OF THE INVENTION WITH OBJECTS

A general object of the present invention is to provide a simplified rotating disk data storage device including apparatus and methods for carrying out error correction coding operations in a manner which overcomes limitations and drawbacks of the prior art.

A more specific object of the present invention is to provide an improved apparatus for generating and recovering Reed-Solomon error correction code syndromes which employs a minimized logic, unitary encoder/decoder structure.

Another specific object of the present invention is to provide a rotating disk data storage subsystem which includes improved apparatus for carrying out error correction calculations and manipulations with the aid of a programmed digital microprocessor in a manner which enables the microprocessor to be available to perform a wide variety of other useful tasks in the data storage subsystem environment.

One more specific object of the present invention is to provide a Galois field for Reed-Solomon error correction processing and a symmetrical syndrome generator polynomial which enables the minimization of hardware elements of a unitized error correction code syndrome generator and decoder.

Yet another specific object of the present invention is to provide a logic-reduced single error correction code syndrome state machine which functions to generate Reed Solomon error correction code syndromes during an encoding process and which functions to decode and check such syndromes during a decoding process.

One more specific object of the present invention is to transfer to a programmed digital microprocessor calculational tasks required for Reed-Solomon error correction processing thereby enabling a dedicated logic encoder/decoder to be implemented with minimized hardware complexity and cost.

In accordance with the invention, a rotating disk data storage subsystem for storing useful data includes a rotating disk having a storage surface in which the data is recorded in blocks of predetermined finite length, a positionable data transducer for reading the data of selected data blocks from the surface, a transducer actuator structure for moving the data transducer among data block locations available on the surface in response to data retrieval commands from a host system and for maintaining the data transducer accurately positioned at each data block location in response to servo information obtained from the data surface, a data controller for managing retrieval of data from the surface via the transducer, a buffer memory for temporarily storing each block of data retrieved from the surface, an interface communicating with the host for sending each data block and status commands to the host and for receiving operational commands from the host, and a single microprocessor controller for controlling the actuator structure in order to position the transducer in order to read and write selected data blocks.

Each block of data includes an error correction code syndrome portion calculated in accordance with a predetermined Galois field error correction algorithm.

The data controller includes a cyclic error correction code syndrome generator for processing each incoming byte of the block in accordance with the said error correction algorithm in a manner which tests for the presence of any errors and which generates error values from which the errors may be located and corrected.

The microprocessor has access to the data controller for testing to determine if the generator has determined the presence of an error for an incoming block, and if so, for obtaining the error values,

The microprocessor is programmed to process the error values to determine the location and nature of at least one error, and has access to the buffer memory whereby a data byte of the block including an error may be removed and a corrected byte substituted in its place.

In one aspect of the present invention, the access by the microprocessor to the buffer memory is via registers of the data controller.

In another aspect of the present invention, the cyclic error correction code syndrome generator comprises a hardware logic apparatus including:

an input/output summing junction for receiving each incoming data block from the tranducer as a clocked data stream of serial bytes,

an error correction code feedback path leading from the summing junction and carring feedback values,

multiplier apparatus for multiplying the feedback values by a first predetermined constant to yield first product values, for multiplying the feedback values by a second predetermined constant to yield second product values, and for multiplying the feedback values by a third predetermined constant to yield third product values,

a first clocked latch stage for latching the feedback values present on the feedback path,

a first summing junction for summing the latched feedback values from the first latch stage with the first product values to yield first sum values,

a second clocked latch stage for latching the first sum values,

a second summing junction for summing the first sum values and the second product values to yield second sum values,

a third clocked latch stage for latching the second sum values,

a third summing junction for summing the second sum values and the third product values to yield sum values,

a fourth clocked latch stage for latching the third sum values,

the input-output summing junction for summing the third sum values with the incoming clocked stream of serial bytes to generate the feedback values,

the first, second, third and fourth latch stages being clocked in synchronism with the incoming data stream of serial bytes, and

a testing circuit for enabling the microprocessor to test for the presence of zero values held in the first, second, third and fourth latch stages at the end of processing of each block thereby to determine that an error has occurred if a non-zero value is present,

and wherein the microprocessor has direct access to the values held in the first, second third and fourth latch stages at the end of processing of each block in order to obtain the values therein if an error is present.

In one more aspect of the present invention, each data block is divided inside the generator into three interleaved parts, wherein each of the first, second, third and fourth latch stages includes three synchronously clocked serial latches, and wherein the syndrome generator calculates three syndromes, each syndrome corresponding to a said interleave.

In yet another aspect of the present invention, each data block includes five hundred twelve data bytes followed by twelve error correction code syndrome bytes, there being four syndrome bytes provided for each said interleave part, and the Galois field GF(28) is generated by the following field generator polynomial:

x8 +x4 +x3 +x2 +1

and wherein the first term thereof is:

x5 +x3 +x+1 (or 00101011 binary).

In one more aspect of the present invention, the first interleave begins with the first data byte and includes every third byte thereafter, the second interleave begins with the second data byte and includes every third byte thereafter, and the third interleave begins with the third byte and includes every third byte thereafter, and wherein the twelve syndrome bytes are appended immediately following the last data byte of the block in the order S3A, S1A, S2A, S3B, S1B, S2B, S3C, S1C, S2C, S3D, S1D, S2D, where S denotes syndrome byte, the numeral denotes the interleave number and the letters A, B, C and D denote respectively the first, second, third and fourth bytes of the syndrome, so that a single block having one burst of 17 bits incorrect may be corrected and up to three bursts of 17 bits incorrect may be detected.

In a still further aspect of the present invention, the error correction algorithm enables an error correction syndrome to be generated by a symmetric syndrome generator polynomial and wherein the third predetermined constant is equal to the first predetermined constant and wherein the multiplier apparatus generates the first product values and the third product values with the same circuit logic elements.

In still another aspect of the present invention, the symmetric syndrome generator polynomial is:

X4 +Alpha18 X3 +Alpha87 X2 +Alpha18 X+1

In one further aspect of the present invention, the first, second, third and fourth latch stages include addressable, enablable bus drivers for enabling syndrome values contained therein at the end of processing of a data block to be obtained and analyzed by a correction computer thereby for locating and correcting at least one data byte determined to be in error.

In one additional aspect of the present invention, a single bus driver is connected to the fourth stage output and a clocking circuit responds to an addressing signal from the microprocessor in order to clock all of the latch stages, so that the microprocessor may thereby obtain all of the syndrome error bytes in sequence.

In yet another aspect of the present invention, additional latch/drivers are attached to the first, second third and fourth stage outputs so that multiple blocks of data may be handled with minimum time loss while error correction is being carried out with respect to one of the blocks.

These and other objects, advantages and features of the present invention will be more fully realized and appreciated by considering the following detailed description of preferred embodiments, presented in conjunction with the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram of three phases of error correction processing of a serial 512 byte data block.

FIG. 2 is a block diagram of a rotating disk data storage subsystem employing the error correction code system of the present invention.

FIG. 3 is a detailed block diagram of an error correction code syndrome generator and detector included within the data controller element depicted in FIG. 2.

FIG. 4 is a layout diagram for a series of sheets of schematic circuit drawings of the error correction code syndrome generator and detector depicted in FIG. 3 and labelled FIGS. 4a, 4b, 4c, 4d, 4e, 4f, 4g, 4h, and 4i. These schematic circuit drawings should be arranged as shown in FIG. 4 and further arranged as four groups to be read from left to right, the first group being FIGS. 4a, 4b and 4c; the second group being FIGS. 4d and 4e; the third group being FIGS. 4f and 4g; and, the fourth group being FIGS. 4h and 4i. Signal buses extending throughout the FIG. 4 circuit bear the same reference numerals.

FIG. 5 depicts an alternative preferred latching circuit for the error correction code syndrome generator and detector of the present invention which enables further reduction of circuitry.

FIG. 6 depicts a second alternative preferred latching circuit for the error correction code syndrome generator and detector of the present invention which enables subsequent data blocks to be read, tested for errors and stored in the buffer if no errors are present while a presently read block is undergoing error correction processing.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

FIG. 1 depicts a block of data. This data may be provided from any source, one commonly encountered source being a host computing system 20 (FIG. 2). The block length is selected in relation to a number of factors, one of which is the ease with which error correction processing may be carried out. In the case of a rotating disk data storage subsystem, one important factor determining block length is the sector space available on the disk storage surface for storage of useful data.

In the FIG. 1 example, the block is 512 eight bit bytes in serial length; and, this length may correspond to one data sector (excluding servo, buffer gap and error correction syndrome byte overhead) of a concentric data track of a disk file subsystem, such as the subsystem 10 depicted in FIG. 2. In one such file with which the present invention may be advantageously employed, for example as described by a commonly assigned U.S. patent application, Ser. No. 834,009 filed on Feb. 27, 1986 and entitled "High Capacity Disk File with Embedded Sector Servo" now U.S. Pat. No. 4,669,004, there are thirty two sectors in each concentric data track, each sector containing 512 data bytes.

During the encoding process for RS error correction in accordance with the principles of the present invention, the 512 byte block is divided into three interleaves as shown by the middle portion of FIG. 1, the two interleaves numbered 1 and 2 being 171 bytes in length and the one numbered 3 being 170 bytes in length. The RS syndrome is simultaneously calculated for each interleave, there being four error correction syndrome bytes calculated for each interleave, bytes S1A, S1B, S1C and S1D for Interleave 1; bytes S2A, S2B, S2C and S2D for Interleave 2; and bytes S3A, S3B, S3C and S3D for Interleave 3. At the completion of the encoding process, the twelve error correction bytes are immediately appended to the end of the data field without any byte gaps, as indicated by the lower portion of FIG. 1, and in the example of disk storage, the block is then recorded onto a selected surface, track and sector of the storage disk.

A generalized summary overview of the rotating disk data storage system 10 incorporating the principles of the present invention is provided by FIG. 2. Therein, the system 10 includes a rotating data storage disk 12 which is rotated at a constant predetermined angular velocity by e.g. a brushless DC direct drive spindle motor 13, and supports at least one data transducer 14 by air bearing effect over the data storage surface thereof, during disk rotation. The transducer 14 is controllably moveable by an actuator structure 16 between concentric data tracks of the data surface of the disk 12. The structure 16 is powered by an electromechanical mover 17 such as a rotary voice coil motor. The magnetic transducer head 14 translates electrical currents into magnetic flux transitions and conversely during write and read operations. These currents are typically converted from and to binary level transitions by conventional read/write channel signal processing circuitry 18.

Incoming data from a source 20, such as a host computing system with which the disk storage subsystem 10 is associated, enters the system 10 through an interface 22. The interface separates data and control signals and decodes commands from the host so that appropriate data storage and retrieval operations may be accomplished by the subsystem 10. The raw incoming data from the host 20 passes through the interface 22 and onto a bus 24 which carries the data to a temporary block buffer storage memory 26. In practice, the memory 26 will have enough storage space to contain at least one block, and often in the case of a disk file, it will hold all of the blocks of an entire concentric data track on the surface 12 (32 blocks in this preferred example).

The buffer 26 is controlled by a data controller 28 which commands read and write operations from and to the buffer 26 and which generates and supplies address and read/write control signals thereto over a special address bus 30. When raw incoming data reaches the interface 22, it signals this arrival to the data controller 28, and the controller 28 thereupon causes the buffer 26 to enter a write mode and generates storage location addresses in proper sequence for each byte of incoming raw data of the block.

A microprocessor controller 32 (such as a type 8031 microprocessor made by Intel Corporation, Santa Clara, Calif., or equivalent) has suitable control programs stored in a read only memory 34 which it addresses over an address bus 36. The controller 32 supervises the operation of the subsystem 10 by communicating over a common data and control bus 38 with the interface 22, the data controller 28 and the read only program memory 34. The microprocessor controller 32 also coordinates and correlates head position and sector location with data in the buffer 26 by obtaining servo head position information from embedded sectors of the disk via the read/write channel 18 and logical block location information from the data controller 28, and thereupon controlling a servo control circuit 39 which in turn operates the actuator motor 17 in a manner described in the referenced co-pending patent application, Ser. No. 834,009, now U.S. Pat. No. 4,669,004, for example. When the correct data sector location is about to pass by the transducer 14, the microprocessor 32 signals the data controller 28, and the raw data block stored in the block buffer 26 passes in serial byte fashion through the data controller 28 wherein it is encoded and bit-serialized, and wherein an RS error correction code syndrome is generated in accordance with the principles of the present invention. The encoding and bit serializing process is described, for example, in a commonly assigned co-pending U.S. patent application, Ser. No. 850,850 filed on Apr. 11, 1986 and entitled "Integrated Encoder Decoder for Variable Length Zero Run Length Limited Codes", now U.S. Pat. No. 4,675,652.

As part of the encoding and decoding process carried out by the data controller 28, the data, whether it be raw data from the buffer 26, or data read from the storage disk 12 by the transducer 14, is passed through an error correction code syndrome generator 40 contained inside the data controller 28. This generator 40, depicted in overview in FIG. 3 and in structural detail in FIGS. 4A, 4B, 4C and 4D, calculates Reed-Solomon ECC syndrome bytes for the three interleaves depicted in FIG. 1 and appends them to the data stream during disk write operations. The particular Galois Field for this preferred RS generator 40 is generated by the following Galois field GF(28) field generator polynomial:

x8 +x4 +x3 +x2 +1

and wherein the first term thereof is:

X5 +x3 +x+1 (or 00101011 binary).

The syndrome bytes are generated in the generator 40 by the following symmetric syndrome generator polynomial:

X4 +Alpha18 X3 +Alpha87 X2 +Alpha18 X+1.

This syndrome generator polynomial is constructed around the Galois Field GF(28) described immediately above.

During disk read operations, the same generator 40 receives the data read from the data surface and calculates Reed-Solomon syndromes for the three interleaves depicted in FIG. 1. The calculation goes on during the transit of the entire block of data between the data surface 12 and the buffer memory 26. At the end of the data controller process for the particular data block, it is now temporarily stored in the buffer memory 26, and the twelve ECC syndrome bytes are latched in twelve single byte latches of the generator 40. Due to the very nature of the particular Reed-Solomon code (described hereinafter) employed in the system 10, at the end of the block read operation, if there are no errors in the recovered data block, all of the syndrome values in the twelve register locations therein will be zero. This no-error/error binary condition is present on a line 127 and its state is then tested by the microprocessor 32. In the event of a tested no-error condition, the microprocessor 32 thereupon commands the data controller 28 to send the present block (sector) through the interface 22 to the host 20 and obtain the next data block in proper logical order from the data surface 12.

In the event that one or more of the twelve syndrome bytes in the twelve register locations are not equal to zero at the end of the data block, an error condition has been detected, and this condition is tested and known by the microprocessor 32. It may command a retry in order to avoid error correction code processing of soft (non-recurrent) errors. Assuming a hard error, the microprocessor 32 then suspends data transfer operations and calls its error correction processing routines and values (such as the Table 1 and Table 2 values hereinafter) which are stored in the read only memory 34.

First, the twelve values held in the twelve syndrome byte registers of the generator 40 are sequenced onto the control bus 38 and loaded into internal registers of the microprocessor 32.

Second, these values are processed in accordance with error location and correction algorithms contained in error correction program routines executed by the microprocessor 32 in order to determine the location of the error and in order to determine the byte value correction in accordance with the error correction coding scheme. These routines are set forth in the source code listing presented hereinafter, reference to which is made for further particulars.

Once the location of the byte in error is discovered, that byte is obtained by the microprocessor 32 from the buffer 26 via special registers of the data controller 28. The microprocessor 32 analyzes the suspect byte and corrects it in accordance with the results of the calculations it has carried out. The corrected byte is then sent back over the control bus 38 and through the data controller 28 to its proper place in the buffer 26.

The calculations performed by the microprocessor 32 upon the syndrome bytes obtained from the generator 40 determine if the error has been successfully corrected or is detectable but uncorrectable. Upon determining that a successful correction has been carried out, the microprocessor 32 commands normal data transfer operations to resume. If an error remains, the microprocessor 32 may command that the data be reread from the data surface, and the correction process repeated. If an error is detectable but is not correctable (as in the case of multiple errors within a single interleave), an appropriate error message is generated and signalled from the microprocessor 32 to the host 20 over the interface 22.

Table 1 which follows sets forth the log table Galois field GF(28) which is used by the generator 40 and which is stored in the read only program memory 34 and used by the microprocessor 32 in executing its program routines for locating and correcting errors.

__________________________________________________________________________01[001] = A 00[000]        38[056] =              A DE[222]                     6F[111] =                           A D4[212]                                  A6[166] =                                        A 54[084]                                              DD[221] =                                                    A 99[153]02[002] = A 3E[062]        39[057] =              A 71[113]                     70[112] =                           A 1D[029]                                  A7[167] =                                        A D7[215]                                              DE[222] =                                                    A 13[019]03[003] = A 14[020]        3A[058] =              A 30[048]                     71[113] =                           A DA[218]                                  A8[168] =                                        A 03[003]                                              DF[223] =                                                    A E1[225]04[004] = A 7C[124]        3B[059] =              A 2D[045]                     72[114] =                           A AF[175]                                  A9[169] =                                        A D2[210]                                              E0[224] =                                                    A 5B[091]05[005] = A 28[ 040]        3C[060] =              A B8[184]                     73[115] =                           A A8[168]                                  AA[170] =                                        A B6[182]                                              E1[225] =                                                    A A3[163]06[006] = A 52[082]        3D[061] =              A 6F[111]                     74[116] =                           A 6E[110]                                  AB[171] =                                        A 47[071]                                              E2[226] =                                                    A 19[025]07[007] = A 24[036]        3E[062] =              A B7[183]                     75[117] =                           A 1B[027]                                  AC[172] =                                        A 7D[125]                                              E3[227] =                                                    A CA[202]08[008] = A BA[186]        3F[063] =              A 5C[092]                     76[118] =                           A 6B[107]                                  AD[173] =                                        A 45[069]                                              E4[228] =                                                    A ED[237]09[009] = A 38[056]        40[064] =              A 75[117]                     77[119] =                           A 74[116]                                  AE[174] =                                        A 32[050]                                              E5[229] =                                                    A 17[023]0A[010] = A 66[102]        41[065] =              A 70[112]                     78[120] =                           A F6[246]                                  AF[175] =                                        A 95[149]                                              E6[230] =                                                    A E6[230]0B[011] = A DD[221]        42[066] =              A CB[203]                     79[121] =                           A 8B[139]                                  B0[176] =                                        A D6[214]                                              E7[231] =                                                    A B1[177]0C[012] = A 90[144]        43[067] =              A D3[211]                     7A[122] =                           A AD[173]                                  B1[177] =                                        A E8[232]                                              E8[232] =                                                    A AC[172]0D[013] = A 49[073]        44[068] =              A CC[204]                     7B[123] =                           A D1[209]                                  B2[178] =                                        A 4D[077]                                              E9[233] =                                                    A 91[145]0E[014]  = A 62[098]        45[069] =              A BB[187]                     7C[124] =                           A F5[245]                                  B3[179] =                                        A 93[147]                                              EA[234] =                                                    A 59[089]0F[015] = A 3C[060]        46[070] =              A AB[171]                     7D[125] =                           A 15[021]                                  B4[180] =                                        A DC[220]                                              EB[235] =                                                    A 23[035]10[016] = A F8[248]        47[071] =              A 83[131]                     7E[126] =                           A 9A[154]                                  B5[181] =                                        A 36[054]                                              EC[236] =                                                    A A9[169]11[017] = A 50[080]        48[072] =              A F2[242]                     7F[127] =                           A 27[039]                                  B6[182] =                                        A 9C[156]                                              ED[237] =                                                    A 72[114]12[018] = A 76[118]        49[073] =              A F4[244]                     80[128] =                           A B3[179]                                  B7[183] =                                        A 6A[106]                                              EE[238] =                                                    A B2[178]13[019] = A 67[103]        4A[074] =              A FE[254]                     81[129] =                           A 3B[059]                                  B8[184] =                                        A 18[024]                                              EF[239] =                                                    A 46[070]14[020] = A A4[164]        4B[075] =              A 85[133]                     82[130] =                           A AE[174]                                  B9[185] =                                        A 96[150]                                              F0[240] =                                                    A 35[053]15[021] = A 48[072]        4C[076] =              A E3[227]                     83[131] =                           A 0E[014]                                  BA[186] =                                        A DB[219]                                              F1[241] =                                                    A 4E[078]16[022] = A 1C[028]        4D[077] =              A 41[065]                     84[132] =                           A 0A[010]                                  BB[187] =                                        A 2E[046]                                              F2[242] =                                                    A  C9[201]17[023] = A 5D[093]        4E[078] =              A 44[068]                     85[133] =                           A 1F[031]                                  BC[188] =                                        A 43[067]                                              F3[243] =                                                    A A6[166]18[024] = A CE[195]        4F[079] =              A 11[017]                     86[134] =                           A 12[018]                                  BD[189] =                                        A 80[129]                                              F4[244] =                                                    A EB[235]19[025] = A EC[236]        50[080] =              A 21[033]                     87[135] =                           A 29[041]                                  BE[190] =                                        A CD[205]                                              F5[245] =                                                    A 2A[042]1A[026] = A 87[135]        51[081] =              A 92[146]                     88[136] =                           A 0B[011]                                  BF[191] =                                        A 63[099]                                              F6[246] =                                                    A 10[016]1B[027] = A 4C[076]        52[082] =              A FB[251]                     89[137] =                           A FD[253]                                  C0[192] =                                        A 89[137]                                              F7[247] =                                                    A 68[104]1C[028] = A A0[160]        53[083] =              A 16[022]                     8A[138] =                           A F9[249]                                  C1[193] =                                        A F0[240]                                              F8[248] =                                                    A 34[052]1D[029] = A F1[241]        54[084] =              A C4[196]                     8B[139] =                           A F9[159]                                  C2[194] =                                        A 4A[074]                                              F9[249] =                                                    A 08[008]1E[030] = A 7A[122]        55[085] =              A 78[120]                     8C[140] =                           A E9[233]                                  C3[195] =                                        A 84[132]                                              FA[250] =                                                    A 53[083]1F[031] = A 79[121]        56[086] =              A 3F[063]                     8D[141] =                           A E5[229]                                  C4[196] =                                        A 7E[126]                                              FB[ 251] =                                                    A E4[228]20[032] = A 37[055]        57[087] =              A F3[243]                     8E[142] =                           A C1[193]                                  C5[197] =                                        A E7[231]                                              FC[252] =                                                    A D8[216]21[033] = A 8D[141]        58[088] =              A 98[152]                     8F[143] =                           A D5[213]                                  C6[198] =                                        A DF[223]                                              FD[253] =                                                    A 73[115]22[034] = A 8E[142]        59[089] =              A 0F[015]                     90[144] =                           A 31[049]                                  C7[199] =                                        A B0[176]                                              FE[254] =                                                    A 65[101]23[035] = A 6D[109]        5A[090] =              A 9E[158]                     91[145] =                           A 1E[030]                                  C8[200] =                                        A A7[167]                                              FF[255] =                                                    A 8C[140]24[036] = A B4[180]        5B[091]  =              A 5E[094]                     92[146] =                           A 33[051]                                  C9[201] =                                        A 97[151]25[037] = A C0[192]        5C[092] =              A D9[217]                     93[147] =                           A EE[238]                                  CA[202] =                                        A BF[191]26[038] = A A5[165]        5D[093] =              A 9D[157]                     94[148] =                           A 3D[061]                                  CB[203] =                                        A 61[097]27[039] = A 06[006]        5E[094] =              A 05[005]                     95[149] =                           A BC[188]                                  CC[204] =                                        A E0[224]28[040] = A E2[226]        5F[095] =              A 8F[143]                     96[150] =                           A C3[195]                                  CD[205] =                                        A EA[234]29[041] = A BD[189]        60[096] =              A 4B[073]                     97[151] =                           A 26[038]                                  CE[206] =                                        A FC[252]2A[042] = A 86[134]        61[097] =              A 0C[012]                     98[152] =                           A 22[034]                                  CF[207] =                                        A CF[207]2B[043] = A 01[001]        62[098] =              A 40[064]                     99[153] =                           A 88[136]                                  D0[208] =                                        A 42[066]2C[044] = A 5A[090]        63[099] =              A A1[161]                     9A[154] =                           A 7F[127]                                  D1[209] =                                        A 25[037]2D[045] = A 60[096]        64[100] =              A 69[105]                     9B[155] =                           A C2[194]                                  D2[210] =                                        A 58[088]2E[046] = A 9B[155]        65[101] =              A 81[129]                     9C[156] =                           A 82[130]                                  D3[211] =                                        A EF[239]2F[047] = A C6[198]        66[102] =              A A2[ 162]                     2D[157] =                           A C7[199]                                  D4[212] =                                        A F7[247]30[048] = A 0D[013]        67[103] =              A BE[190]                     9E[158] =                           A 4F[079]                                  D5[213] =                                        A 2C[044]31[049] = A 02[002]        68[104] =              A 04[004]                     9F[159] =                           A 2F[047]                                  D6[214] =                                        A AA[170]32[050] = A 2B[043]        69[105] =              A 1A[026]                     A0[160] =                           A 5F[095]                                  D7[215] =                                        A 55[085]33[051] = A 64[100]        6A[106] =              A B9[185]                     A1[161] =                           A 51[081]                                  D8[216] =                                        A 07[007]34[052] = A C5[197]        6B[107] =              A 6C[108]                     A2[162] =                           A D0[208]                                  D9[217] =                                        A 57[087]35[053] = A 7B[123]        6C[108] =              A C8[200]                     A3[163] =                           A 20[032]                                  DA[218] =                                        A 94[148]36[053] = A 8A[138]        6D[109] =              A 56[086]                     A4[164] =                           A 3A[058]                                  DB[219] =                                        A 09[009]37[055] = A FA[250]        6E[110] =              A 39[057]                     A5[165] =                           A B5[181]                                  DC[220] =                                        A 77[119]__________________________________________________________________________

In Table 1, A represents Alpha to the power which follows it. The numbers to the left of the equal sign equal the Alpha value to the left thereof, first in Hex, and then in decimal values enclosed by the brackets.

Table 2 which follows sets forth the anti-log table Galois field GF(28) which is stored in the program read only memory 34 and used by the microprocessor 32 in executing its program routines for locating and correcting errors, based on non-zero syndrome bytes.

__________________________________________________________________________A 00[000] =  01[001]        A 37[055] =               20[032]                     A 6E[110] =                            74[116]                                  A A5[165] =                                         26[038]                                              A DC[220] =                                                     B4[180]A 01[001] =  2B[043]        A 38[056] =               09[009]                     A 6F[111] =                            3D[064]                                  A A6[166] =                                         F3[243]                                              A DD[221] =                                                     0B[011]A 02[002] =  31[049]        A 39[057] =               6E[110]                     A 70[112] =                            41[065]                                  A A7[167] =                                         C8[200]                                              A DE[222] =                                                     38[056]A 03[003] =  A8[168]        A 3A[058] =               A4[164]                     A 71[113] =                            39[057]                                  A A8[168] =                                         73[115]                                              A DF[223] =                                                     C6[198]A 04[004] =  68[ 104]        A 3B[059] =               81[129]                     A 72[114] =                            ED[237]                                  A A9[169] =                                         EC[236]                                              A E0[224] =                                                     CC[204]A 05[005] =  5E[094]        A 3C[060] =               0F[015]                     A 73[115] =                            FD[253]                                  A AA[170] =                                         D6[214]                                              A E1[225] =                                                     DF[223]A 06[006] =  27[039]        A 3D[061] =               94[148]                     A 74[116] =                            77[119]                                  A AB[171] =                                         46[070]                                              A E2[226] =                                                     28[040]A 07[007] =  D8[216]        A 3E[062] =               02[002]                     A 75[117] =                            40[064]                                  A AC[172] =                                         E8[232]                                              A E3[227] =                                                     4C[076]A 08[008] =  F9[249]        A 3F[063] =               56[086]                     A 76[118] =                            12[018]                                  A AD[173] =                                         7A[122]                                              A E4[228] =                                                     FB[251]A 09[009] =  DB[219]        A 40[064] =               62[098]                     A 77[119] =                            DC[220]                                  A AE[174] =                                         82[130]                                              A E5[229] =                                                     8D[141]A 0A[010] =  84[132]        A 41[065] =               4D[077]                     A 78[120] =                            55[085]                                  A AF[175] =                                         72[114]                                              A E6[220] =                                                     E6[220]A 0B[011] =  88[136]        A 42[066] =               D0[208]                     A 79[121] =                            1F[031]                                  A B0[176] =                                         C7[199]                                              A E7[231] =                                                     C5[197]A 0C[012] =  61[097]        A 43[067] =               BC[188]                     A 7A[122] =                            1E[030]                                  A B1[177] =                                         E7[231]                                              A E8[232] =                                                     B1[177]A 0D[ 013] =  30[048]        A 44[068] =               4E[078]                     A 7B[123] =                            35[053]                                  A B2[178] =                                         EE[238]                                              A E9[233] =                                                     8C[140]A 0E[014] =  83[133]        A 45[069] =               AD[173]                     A 7C[124] =                            04[004]                                  A B3[179] =                                         80[128]                                              A EA[234] =                                                     CD[205]A 0F[015] =  59[089]        A 46[070] =               EF[239]                     A 7D[125] =                            AC[172]                                  A B4[180] =                                         24[036]                                              A EB[235] =                                                     F4[244]A 10[016] =  F6[246]        A 47[071] =               AB[171]                     A 7E[126] =                            C4[196]                                  A B5[181] =                                         A5[165]                                              A EC[236] =                                                     19[025]A 11[017] =  4F[079]        A 48[072] =               15[021]                     A 7F[127]  =                            9A[145]                                  A B6[182] =                                         AA[170]                                              A ED[237] =                                                     E4[228]A 12[018] =  86[134]        A 49[073] =               0D[013]                     A 80[128] =                            BD[189]                                  A B7[183] =                                         3E[062]                                              A EE[238] =                                                     93[147]A 13[019] =  DE[222]        A 4A[074] =               C2[194]                     A 81[129] =                            65[101]                                  A B8[184] =                                         3C[060]                                              A EF[239] =                                                     D3[211]A 14[020] =  03[003]        A 4B[075] =               60[096]                     A 82[130] =                            9C[156]                                  A B9[185] =                                         6A[106]                                              A F0[240] =                                                     C1[193]A 15[021] =  7D[125]        A 4C[076] =               1B[027]                     A 83[131] =                            47[071]                                  A BA[186] =                                         08[008]                                              A F1[241] =                                                     1D[029]A 16[022] =  53[083]        A 4D[077] =               B2[178]                     A 84[132] =                            C3[195]                                  A BB[187] =                                         45[069]                                              A F2[242] =                                                     48[072]A 17[023] =  E5[229]        A 4E[078] =               F1[241]                     A 85[133] =                            4B[074]                                  A BC[188] =                                         95[149]                                              A F3[243] =                                                     57[087]A 18[024] =  B8[184]        A 4F[079] =               9E[158]                     A 86[134] =                            2A[042]                                  A BD[189] =                                         29[041]                                              A F4[244] =                                                     49[073]A 19[025] =  E2[226]        A 50[080] =               11[017]                     A 87[135] =                            1A[026]                                  A BE[190] =                                         67[103]                                              A F5[245] =                                                     7C[124]A 1A[026] =  69[105]        A 51[081] =               A1[161]                     A 88[136] =                            99[153]                                  A BF[191] =                                         CA[202]                                              A F6[246] =                                                     78[120]A 1B[027] =  75[117]        A 52[082] =               06[006]                     A 89[137] =                            C0[192]                                  A C0[192] =                                         25[037]                                              A F7[247] =                                                     D4[212]A 1C[028] =  16[022]        A 53[083] =               FA[250]                     A 8A[138] =                            36[054]                                  A C1[193] =                                         8E[141]                                              A F8[248] =                                                     10[016]A 1D[029] =  70[112]        A 54[084] =               A6[166]                     A 8B[139] =                            79[121]                                  A C2[194] =                                         9B[155]                                              A F9[249] =                                                     8A[138]A 1E[030] =  91[145]        A 55[085] =               D7[215]                     A 8C[140] =                            FF[ ] A C3[195] =                                         96[150]                                              A FA[250] =                                                     37[055]A 1F[031] =  85[113]        A 56[086] =               6D[109]                     A 8D[141] =                            21[033]                                  A C4[196] =                                         54[083]                                              A FB[251] =                                                     52[082]A 20[032] =  A3[163]        A 57[087] =               D9[217]                     A 8E[142] =                            22[034]                                  A C5[197] =                                         34[052]                                              A FC[252] =                                                     CE[206]A 21[033] =  50[080]        A 58[088] =               D2[210]                     A 8F[143] =                            5F[095]                                  A C6[198] =                                         2F[047]                                              A FD[253] =                                                     89[237]A 22[034] =  98[152]        A 59[089] =               EA[234]                     A 90[144] =                            0C[012]                                  A C7[199] =                                         9D[157]                                              A FE[254] =                                                     4A[074]A 23[035] =  EB[235]        A 5A[ 090] =               2C[044]                     A 91[145] =                            E9[233]                                  A C8[200] =                                         6C[108]A 24[036] =  07[007]        A 5B[091] =               E0[224]                     A 92[146] =                            51[081]                                  A C9[201] =                                         F2[242]A 25[037] =  D1[209]        A 5C[092] =               3F[063]                     A 93[147] =                            B3[179]                                  A CA[202] =                                         E3[227]A 26[038] =  97[151]        A 5D[093] =               17[023]                     A 94[148] =                            DA[218]                                  A CB[203] =                                         42[066]A 27[039] =  7F[127]        A 5E[094] =               5B[091]                     A 95[149] =                            AF[175]                                  A CC[204] =                                         44[068]A 28[040] =  05[005]        A 5F[095] =               A0[160]                     A 96[150] =                            B9[185]                                  A CD[205]  =                                         BE[190]A 29[041] =  87[135]        A 60[096] =               2D[045]                     A 97[151] =                            C9[201]                                  A CE[206] =                                         18[024]A 2A[042] =  F5[245]        A 61[097] =               CB[203]                     A 98[152] =                            58[088]                                  A CF[207] =                                         CF[207]A 2B[043] =  32[050]        A 62[098] =               0E[014]                     A 99[153] =                            DD[221]                                  A D0[208] =                                         A2[162]A 2C[044] =  D5[213]        A 63[099] =               BF[191]                     A 9A[154] =                            7E[126]                                  A D1[209] =                                         7B[123]A 2D[045] =  3B[059]        A 64[100] =               33[051]                     A 9B[155] =                            2E[076]                                  A D2[210] =                                         A9[169]A 2E[046] =  BB[187]        A 65[101] =               FE[254]                     A 9C[156] =                            B6[182]                                  A D3[211] =                                         43[067]A 2F[047] =  9F[159]        A 66[102] =               0A[010]                     A 9D[157] =                            5D[093]                                  A D4[212] =                                         6F[111]A 30[048] =  3A[058]        A 67[103] =               13[019]                     A 9E[158] =                            5A[090]                                  A D5[213] =                                         8F[143]A 31[049] =  90[144]        A 68[104] =               F7[247]                     A 9F[159] =                            8B[139]                                  A D6[214] =                                         B0[176]A 32[050] =  AE[174]        A 69[105] =               64[100]                     A A0[160] =                            1C[028]                                  A D7[215] =                                         A7[167]A 33[051] =  92[146]        A 6A[106] =               B7[183]                     A A1[161] =                            63[099]                                  A D8[216] =                                         FC[252]A 34[052] =  F8[248]        A 6B[107] =               76[118]                     A A2[162] =                            66[102]                                  A D9[217] =                                         5C[092]A 35[053] =  F0[240]        A 6C[108] =               6B[107]                     A A3[163] =                            E1[225]                                  A DA[218] =                                         71[113]A 36[054] =  B5[181]        A 6D[109] =               23[035]                     A A4[164] =                            14[020]                                  A DB[219] =                                         BA[186]__________________________________________________________________________

In Table 2, A represents Alpha to the power which follows it. The numbers to the right of the equal sign equal the Alpha value to the left thereof, first in Hex, and then in decimal values enclosed by the brackets.

The error correction code syndrome generator 40, depicted in overview in FIG. 3 and in structural and electrical detail in the FIGS. 4a-i schematic. The generator 40 computes a byte-based syndrome or remainder based upon a Reed-Solomon polynomial. A four byte syndrome is calculated for each interleave row depicted in FIG. 1. Thus, the generator processes incoming data bytes in groups of three.

Conceptually, the multipliers 60, 66, 72 of the syndrome generator 40 function as three table look-up read only memories: each maps eight bits in to eight bits out. However, by use of a symmetrical Reed-Solomon code with minimized logic equations, instead of three read only memories, the circuitry 40 has been compacted so that only fifty two exclusive OR gates are required, together with twelve data byte latches, and a syndrome recovery circuit. In fact, the multiplier 72 is not required to be implemented as its function is provided by the multiplier 60.

In the encode process, a block of eight bit data bytes in serial format is read out of the block buffer 26 over the data bus 24 and enters the syndrome generator via a selectable internal bus 42. The incoming data passes through an input/output multiplying junction 52 where it is multiplied by values already resident in the last latch 141 of the stage 74 of the generator 40.

An AND gate 54 enables the product of the incoming data and least stage data to be multiplied by zero and thereby have a zero value. By cycling zero values on an error correction feedback path 50 the multiplication function of the generator 40 may be halted.

The incoming data, as multiplied, then becomes a cyclically recirculating error correction code feedback byte stream on the path 50. The feedback bytes circulate to a three byte latch 56 and to three multipliers 60, 66 and 72. Three bytes are successively clocked into the latch 56 by clocking signals on an ECC clock line 48. As the three bytes are clocked sequentially through the latch 56 each is added in turn at a first summing junction 58 to the product generated by a first multiplier 60. The first multiplier multiplies the present byte value on the ECC feedback path 50 by a predetermined constant, Alpha 18 (which is B8 in HEX and 184 in decimal base). The resultant first sum values are then latched in turn into and through a second three byte latch 62.

The latched first sums clock through the second latch 62 in synchronism with the operations of the first latch 56, and each byte value is added in turn at a second summing junction 64 to a second product generated by a second multiplier 66. The second multiplier 66 multiplies the present byte value on the ECC feedback path 50 by a second predetermined constant, Alpha 87 (which is 1A in Hex and 026 in decimal notation). The resultant second sum values are then latched in turn into and through a third three byte latch 68.

The latched second sum values are clocked through the third latch 68 in synchronism with the operations of the first 56 and second 62 latches. Each byte value is summed in turn at a third summing junction 70 with a third product generated by a third multiplier 72. The third product is generated by multiplying the present byte value on the ECC feedback path with a predetermined constant. In the preferred embodiment 40 of the ECC syndrome generator, since the RS code is generated by a symmetrical generator polynomial, the product entering the third summing junction 70 is the same value as is calculated at the same time by the first multiplier 60 (present byte value times Alpha 18) Thus, in the preferred generator 40 there are no logic elements required for implementation of the multiplier 70 beyond those required for the first multiplier 60 (and the third multiplier 72 is thus shown in FIG. 3 in phantom). The resultant third sum values are then latched in turn into and through a fourth three byte latch 74.

The latched third sum values are then clocked through the fourth latch 74 in synchronism with the operations of the latches 56, 62, and 68. Each third sum value is added in turn at the input/output multiplying junction 52 to the incoming data on the internal bus 42. Thus, it is seen that the feedback signal on the line 50 is a function of incoming data summed with the third sum values. The entire byte stream of the data block recirculates cyclically through the syndrome generator 40 in accordance with its encoding algorithm, until the end of the block is reached.

As the last data byte of the current data block (byte number 511) has passed through the generator 40, the next twelve bytes comprise the error correction code syndrome bytes for this current data block, and they are present in the latches 56, 62, 68 and 74. The syndrome bytes are then clocked in turn through a two input, single output data bus multiplexer 43 and onto an output bus 44 inside the data controller 28 and thereby become appended to the end data block as it passes through the subsequent variable length, run length limited (e.g., 1, 7) encoding process carried out inside the data controller as, for example, in accordance with the disclosure of the referenced co-pending patent application Ser. No. 850,850. A block counter inside of the data controller 28 counts the number of bytes and switches the multiplexer 43 when 512 data bytes of the block have appeared on the bus 42.

With reference now to the specific implementation of the syndrome generator 40 as depicted in FIGS. 4a-i, each latch 56, 62, 68, and 74 is virtually identical with the others, and each summing junction 58, 64, 70 and 52 is virtually identical with the others. The first latch 56 and summing junction 58 depicted in FIGS. 4a, b and c will now be described in some detail, with the understanding being that this description applies to each of the other latches 62, 68 and 74 and summing junctions 64, 70 and 52. The multipliers 60, 66 and 72 are different and will be explained.

The eight bit lines of the error correction feedback path 50 enter eight inputs of an eight bit D register 130 configured as a latch. The register 130, as is true with all eleven other D registers 131, 132, 133, 134, 135, 136, 137, 138, 139, 140 and 141, is clocked by a clocking signal on the ECC clock line 48 and is reset by a reset signal on an ECC reset line 49. When the register 130 is clocked, the values appearing on the path 50 become latched internally and appear on an eight bit output bus 80 which leads to the next register 131 and which also leads to a tri-state bus buffer 81 and to a logic array 82. The logic array 82 is provided in order to test if all eight of the bit values are zero during data recovery from the disk and after a block of data and its twelve syndrome bytes have circulated through the syndrome generator. (When there is no error in the recovered data, the bit values on the bus 80 will be zero). This zero condition is fed forward to a ninth input of the next array 86 via a line 83. There are twelve zero-check arrays 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, and 126, each being associated respectively with registers 130 through 141. The output of each register feeds forward to a ninth input of the next register, so that the last register 126 accumulates the zero states of every preceding register, i.e. all preceding registers must be zero before the last register 126 can be zero, and it will be zero only if all bit positions of the last D register 141 with which it is associated are also zero when the test is made. In this manner, the single bit line 127 indicates the zero/non-zero status of the syndrome bytes.

In the event that an error is present and that one or more of the arrays 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126 has an output which is not zero, this condition will be detected by the microprocessor 32 by its periodic scanning of the control line 127; and it will thereupon collect all of the byte values present in each of the latches 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141 and 142, via its respective tri-state bus buffer/driver 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, and 125.

An output from the tri-state buffer 81 extends to the control bus 38. When the microprocessor 32 desires to examine the contents of the tri-state register 81, an address signal is delivered over an address line ADREG 36 to the register 81 and it causes it to latch the bit values present on the bus 80 and to push those values onto the control bus 38 where they are obtained by the microprocessor 32 and entered into one of its internal eight bit registers. A separate address line extends to each of the other tri-state buffers, and the microprocessor 32 enables each address line in a predetermined order, so that all of the byte values held in the twelve latches are delivered to the microprocessor 32 which thereupon uses these values to locate one or more errors in the data block and to correct those errors.

An output bus 84 of the next latch 131 extends to the inputs of a third latch 132 and to a tri-state bus buffer 85 and to a logic array 86 which has nine inputs, eight from the bus 84, and the output line 83 from the preceding logic array 82. If all of the bit values on the bus 84 and the bit value on the line 83 are zero, then the output line 87 of the array 86 is also zero.

An output bus 88 of the third latch extends to the first summing junction 58. The eight bit lines of the bus 88 connect to one of the two inputs of eight exclusive OR gates 150, 151, 152, 153, 154, 155, 156, and 157 which make up the first summing junction 58. Each of the other of the two inputs for each of the gates is a line leading from the first multiplier 60.

The first multiplier 60 multiplies the byte value on the feedback path by the predetermined constant ALPHA 18, to yield a first product value, and this first product is then applied to the other inputs of the eight gates 150-157 making up the first summing junction 58.

The first multiplier 60 includes 12 exclusive OR gates 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, and 171, connected as shown in FIGS. 4b and c. Single bit values are generated and sent out over the nine bit lines comprising the bus 76, five of them leading to the second multiplier 66 and seven of them leading to the third multiplier 72. Eight selected single bit values are applied to the first summing junction 58 in the arrangement shown in FIG. 4b, the bit value entering the Exclusive-OR 156 coming directly from the third bit position of the ECC feedback path 50, rather than the multiplier 60. The same eight bit lines connect to the third summing junction 70 as shown in FIG. 4g, thereby avoiding the need for any circuitry for the third multiplier 72 in this preferred embodiment 40.

The second latch 62, second multiplier 66 and second summing junction are depicted in FIGS. 4d and e. The second multiplier 66 includes eight exclusive OR gates 191, 192, 193, 194, 195, 196, 197 and 198, each having its two inputs connected to the ECC feedback bus 50 and to the bus 76 in a connection arrangement as shown in FIG. 4e. The multiplier 66 multiplies each byte value on the ECC feedback path 50 by a constant, ALPHA 87, to yield the second product, and this eight bit value is applied to the other inputs of eight exclusive OR gates 180, 181, 182, 183, 184, 185, 186, and 187, making up the second summing junction 64.

As already mentioned, because of the symmetrical nature of the Reed Solomon code selected, the third multiplier 72 is not required and, as seen in FIG. 4g, it does not exist. The third summing junction 70 comprising eight exclusive OR gates 200, 201, 202, 203, 204, 205, 206 and 207, combines the bytes clocked from the latch 138 by the first product generated by the first multiplier 60. The bit values of each serial byte put into the generator 40 on the internal bus 42 are applied to the other of the inputs of each of the array of eight exclusive OR gates 200, 201, 202, 203, 204, 205, 206, and 207 forming the input/output multiplying junction 52. An array of eight AND gates 220, 221, 222, 223, 224, 225, 226 and 227 and serial inverters 230, 231, 232, 233, 234, 235, 236, and 237 form the AND gate 54 which leads directly to the ECC feedback bus 50.

With the circuitry illustrated and with the particular RS error correction code, it is possible to correct any data block (sector) with one burst of 17 bits incorrect, and to detect any sector with up to three bursts of 17 bits incorrect.

In FIG. 5, the number of tri-state bus drivers has been reduced from 12 to one, namely the driver 126 connected to the last latch 141. In this alternative preferred embodiment of the generator 40', a simple logic circuit 300 is responsive to a single address enable line 301 controlled by the microprocessor 32. Every time that the microprocessor addresses the driver 126 via the line 301, the circuit 300, after a suitable time delay, generates a clock signal which is put out to all of the latches over the line 48'. Thus, with each clock pulse on the line 48, the syndrome byte values shift one latch to the right, in lock step. Finally, each syndrome byte reaches the last latch 141 and is then sent out over the control bus by the tri-state driver 126. Thus, in this alternative, the microprocessor 32 addresses the buffer 126 over a single address line 301 twelve times in order to cause the buffer 126 to place each syndrome byte onto the control bus 38. Each byte of the error syndrome is then taken into and stored in internal registers of the microprocessor 32 in its proper turn over the control bus 38.

In the FIG. 6 alternative embodiment 40" of the error correction syndrome generator of the present invention, the twelve tri-state drivers 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121 and 125, addressed respectively by address lines a, b, c, d, e, f, g, h, i, j, k and l, are mirrored by twelve additional latch-drivers 381, 385, 389, 393, 397, 401, 405, 409, 413, 417, 421, and 425, each of which is connected in parallel across the driver having in common the last two digits of the reference numerals. These additional latch-drivers 381 through 425 are commonly enabled by a suitable control line in order to capture the twelve syndrome bytes of a data block determined to contain one or more errors. The latch drivers 381 through 425 are addressed respectively by address lines m, n, o, p, q, r, s, t, u, v, w and x. All of the address lines a-x are under the control of the microprocessor 32. With the FIG. 6 arrangement, the microprocessor 32 may be addressing the latch set of the driver 381 through 425 in order to obtain error correction syndrome bytes of a sector determined to have an error, while the next sector is being circulated through the error correction syndrome generator 40" which is otherwise identical to the generator 40.

In this manner, multiple blocks of data, as many as 32 blocks per concentric data track on the surface 12 may be checked by the generator 40 and loaded into the block buffer memory 26 (which is appropriately sized to contain multiple blocks, preferably all of the data blocks of a concentric data track) while the microprocessor 32 performs error correction on one of the blocks determined to be in error. With this slightly greater logic overhead, multiple passes (revolutions) over the data track by the transducer 14 are kept to a minimum, thereby increasing the data throughout of the system 10 while still providing full error correction capability.

Here follows a source code listing of control program routines by which the microprocessor 32 may carry out Reed-Solomon error correction procedures in the disk drive subsystem 10 depicted in FIGS. 1-3 and 4a-4: ##SPC1##

Having thus described a presently preferred embodiment of the present invention, it will now be appreciated that the objects of the invention have been fully achieved, and it will be understood by those skilled in the art that many changes in construction and circuitry and widely differing embodiments and applications of the invention will suggest themselves without departing from the spirit and scope of the invention. The disclosures and the description herein are intended to be illustrative and are not in any sense limiting of the invention, more preferably defined in scope by the following claims.

Patent Citations
Cited PatentFiling datePublication dateApplicantTitle
US4410989 *Dec 11, 1980Oct 18, 1983Cyclotomics, Inc.Bit serial encoder
US4564945 *Jun 20, 1983Jan 14, 1986Reference Technology, Inc.Error-correction code for digital data on video disc
US4567594 *Jun 7, 1983Jan 28, 1986Burroughs CorporationIn a disk storage system
US4608692 *Sep 6, 1984Aug 26, 1986Kabushiki Kaisha ToshibaError correction circuit
US4633471 *Sep 19, 1983Dec 30, 1986Storage Technology Partners IiError detection and correction in an optical storage system
US4642808 *Jan 30, 1986Feb 10, 1987U.S. Philips CorporationDecoder for the decoding of code words which are blockwise protected against the occurrence of a plurality of symbol errors within a block by means of a reed-solomon code, and reading device for optically readable record carriers
Referenced by
Citing PatentFiling datePublication dateApplicantTitle
US4829525 *Oct 23, 1987May 9, 1989Mitsubishi Denki Kabushiki KaishaPCM signal reproducing apparatus including error/erasure correction circuit
US4907181 *Jun 8, 1988Mar 6, 1990Robert Bosch GmbhTest and monitoring system for a digital video tape recorder/reproducer
US5151905 *Oct 10, 1989Sep 29, 1992Sony CorporationData recording method
US5157670 *Mar 4, 1992Oct 20, 1992Avasem CorporationError correction code interruption system
US5163162 *Nov 14, 1990Nov 10, 1992Ibm CorporationSystem and method for data recovery in multiple head assembly storage devices
US5241546 *Feb 1, 1991Aug 31, 1993Quantum CorporationOn-the-fly error correction with embedded digital controller
US5280488 *Nov 8, 1990Jan 18, 1994Neal GloverReed-Solomon code system employing k-bit serial techniques for encoding and burst error trapping
US5291496 *Oct 18, 1990Mar 1, 1994The United States Of America As Represented By The United States Department Of EnergyFault-tolerant corrector/detector chip for high-speed data processing
US5317713 *Sep 19, 1991May 31, 1994Quantum CorporationMicro-winchester disk drive having on-board segmented cache memory
US5335234 *May 7, 1993Aug 2, 1994Dell Usa, L.P.Error correction code pipeline for interleaved memory system
US5375127 *Mar 25, 1992Dec 20, 1994Ncr CorporationIn a data storage system
US5392299 *Jan 15, 1992Feb 21, 1995E-Systems, Inc.Triple orthogonally interleaed error correction system
US5422895 *Jan 9, 1992Jun 6, 1995Quantum CorporationCross-checking for on-the-fly Reed Solomon error correction code
US5428630 *Jul 1, 1993Jun 27, 1995Quantum Corp.System and method for verifying the integrity of data written to a memory
US5465343 *Apr 30, 1993Nov 7, 1995Quantum CorporationShared memory array for data block and control program storage in disk drive
US5517634 *Jun 23, 1992May 14, 1996Quantum CorporationDisk drive system including a DRAM array and associated method for programming initial information into the array
US5659557 *May 3, 1993Aug 19, 1997Cirrus Logic, Inc.Reed-Solomon code system employing k-bit serial techniques for encoding and burst error trapping
US5691994 *May 8, 1995Nov 25, 1997Western Digital CorporationDisk drive with fast error correction validation
US5761220 *May 9, 1997Jun 2, 1998Cirrus Logic, Inc.Minimum latency asynchronous data path controller in a digital recording system
US5778009 *Jun 14, 1995Jul 7, 1998Quantum CorporationDedicated ALU architecture for 10-bit Reed-Solomon error correction module
US5812564 *May 8, 1995Sep 22, 1998Western Digital CorporationDisk drive with embedded finite field processor for error correction
US5875200 *Mar 28, 1997Feb 23, 1999Cirrus Logic, Inc.Reed-Solomon code system employing k-bit serial techniques for encoding and burst error trapping
US6003151 *Mar 24, 1997Dec 14, 1999Mediatek Inc.Error correction and detection system for mass storage controller
US6079044 *Jul 14, 1997Jun 20, 2000International Business Machines CorporationMethod and error correcting code (ECC) apparatus for storing predefined information with ECC in a direct access storage device
US6128698 *Aug 4, 1997Oct 3, 2000Exabyte CorporationTape drive emulator for removable disk drive
US6279135 *Nov 19, 1998Aug 21, 2001Lsi Logic CorporationOn-the-fly row-syndrome generation for DVD controller ECC
US6378100 *Dec 22, 1998Apr 23, 2002U.S. Philips CorporationMethod and apparatus for encoding multiword information with error locative clues directed to low protectivity words
US6401228 *Apr 20, 1999Jun 4, 2002Sony CorporationData decoding apparatus and method and data reproduction apparatus
US6457156 *Jan 29, 1998Sep 24, 2002Adaptec, Inc.Error correction method
US7864471Jul 24, 2008Jan 4, 2011Seagate Technology LlcConverting timing errors into symbol errors to handle write mis-synchronization in bit-patterened media recording systems
US8130459Jan 4, 2011Mar 6, 2012Seagate Technology LlcConverting timing errors into symbol errors to handle write mis-synchronization in bit-patterned media recording systems
WO1997000559A1 *Jun 10, 1996Jan 3, 1997Quantum CorpDedicated alu architecture for 10-bit reed-solomon error correction module
WO1999006912A1 *Aug 4, 1998Feb 11, 1999Exabyte CorpTape drive emulation by removable disk drive and media formatted therefor
Classifications
U.S. Classification714/756, G9B/20.049, 360/40, 714/762
International ClassificationH03M13/15, G11B20/18
Cooperative ClassificationH03M13/15, G11B20/1809
European ClassificationH03M13/15, G11B20/18B1
Legal Events
DateCodeEventDescription
May 16, 2000FPExpired due to failure to pay maintenance fee
Effective date: 20000308
Mar 5, 2000LAPSLapse for failure to pay maintenance fees
Sep 28, 1999REMIMaintenance fee reminder mailed
Oct 20, 1997ASAssignment
Owner name: CANADIAN IMPERIAL BANK, AS ADMINISTRATIVE AGENT, N
Free format text: RELEASE;ASSIGNOR:QUANTUM CORPORATION;REEL/FRAME:008744/0904
Effective date: 19970818
Sep 5, 1995FPAYFee payment
Year of fee payment: 8
Oct 4, 1994ASAssignment
Owner name: CANADIAN IMPERIAL BANK OF COMMERCE, AS ADMINIST
Free format text: SECURITY INTEREST;ASSIGNOR:QUANTUM CORPORATION;REEL/FRAME:007152/0815
Effective date: 19941003
Aug 30, 1991FPAYFee payment
Year of fee payment: 4
Jul 24, 1987ASAssignment
Owner name: QUANTUM CORPORATION, 1804 MCCARTHY BOULEVARD, MILP
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST.;ASSIGNOR:QUANTRUM CORPORATION, A CA CORP.;REEL/FRAME:004740/0317
Effective date: 19870714
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:QUANTRUM CORPORATION, A CA CORP.;REEL/FRAME:4740/317
Owner name: QUANTUM CORPORATION,CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:QUANTRUM CORPORATION, A CA CORP.;REEL/FRAME:004740/0317
May 30, 1986ASAssignment
Owner name: QUANTUM CORPORATION, 1804 MCCARTHY BOULEVARD, MILP
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST.;ASSIGNOR:MACHADO, MICHAEL G.;REEL/FRAME:004562/0005
Effective date: 19860530
Owner name: QUANTUM CORPORATION, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MACHADO, MICHAEL G.;REEL/FRAME:004562/0005