Generic software interface for hardware environments having executing code registers itself and the code for a next suboperation

Abstract

A generic interface layer for providing a generic interface to a hardware environment for a program executing on the hardware environment. The generic interface layer, is interrupt-driven. It includes driver code for devices in the hardware environment that is executed in response to software interrupts from the program and interrupt handling code for handling interrupts from the hardware environment. The interrupt handling code responds to an interrupt by calling a callback in the program. The generic interface layer includes a loader for loading the program and a debugger for controlling execution of the program. Execution of code in the generic interface layer may be coordinated by the system timer interrupt code that is executed in response to a system timer interrupt. Code that is executing in the generic interface layer may register itself or other code with the system timer interrupt code, which then executes the code in response to a system timer interrupt. One use of the technique is to permit driver code to register other code and then quickly return to the program and thereby prevent long suspension of the program. Also disclosed is a technique for managing a statically-allocated array of buffers for receiving LAN packets to reduce the frequency of an "out of resource" condition.

Claims

What is claimed is:

1. A generic interface layer which executes in a hardware environment, the hardware environment including a plurality of devices and producing a plurality of interrupts and the generic interface layer being used by an executing program to control and respond to the hardware environment, the generic interface layer comprising:

executable code including

software interrupt-driven driver code for the devices and

interrupt handler code for the interrupts, the interrupt handler code executing in response to the interrupts to perform callbacks to callback code in the program; and

a generic interface of software interrupts that the program uses to execute the driver code and wherein

the interrupts include a system clock interrupt;

the interrupt handler code includes system clock interrupt handler code that is executed in response to the system clock interrupt; and

code executing in the generic interface layer may register itself or other code with the system clock interrupt handler, the registered code being executed when the system clock interrupt handler code is executed.

2. The generic interface layer set forth in claim 1 wherein:

executing driver code registers other code with the system clock interrupt handler and returns, whereby the program does not suspend execution until completion of execution of the other code.

3. The generic interface layer set forth in claim 1 further comprising:

a stack upon which the interrupt handler code and the callback code execute.

4. The generic interface layer set forth in claim 3 wherein:

the stack is accessible to the program.

5. The generic interface layer set forth in claim 1 further comprising:

loader code that, when executed, loads the program and sets up the hardware environment so that the hardware environment begins executing the program,

the loader code including file locator code that, when executed, locates the program in a set of files that are accessible via the hardware environment.

6. The generic interface layer set forth in claim 5 wherein:

the file locator code further locates the program in sets of different kinds of files that are accessible via the hardware environment.

7. Apparatus for carrying out an operation for a program without suspending execution of the program until completion of the operation, the apparatus comprising:

a register data structure in which executing code registers itself or other code;

system clock interrupt handler code which executes in response to a system clock interrupt, the system clock interrupt handler code operating during execution to execute code registered in the register data structure; and

code for a plurality of suboperations of the operation, the code for the first suboperation registering the code for a next one of the suboperations and returning.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The invention relates generally to interfaces used by programs to control and respond to components of a computer system and more specifically to the interfaces used by programs to control and respond to hardware environments.

2. Description of the Prior Art

When all is said and done, what a computer program does is control and respond to hardware devices. When a user types a character on the keyboard, the program executing on the computer system responds to the input from the keyboard hardware by causing the computer system to execute instructions which in turn cause the display terminal to display the typed character. Because the computer program controls and responds to hardware devices, the instructions in the program vary depending on the kinds of hardware devices being used.

One example of this is the form of the instructions themselves: each kind of computer has a set of instructions defined for it, and a program which is to execute on that kind of computer must be written using that set of instructions. Another example is the kinds of peripheral devices in the computer system. A peripheral device is a device such as a keyboard, a display, a disk drive, or a printer that works with the computer but is separate from it. A program written for a system with one kind peripheral device will not work on a system that uses a different kind of peripheral device, even though both systems have a computer that executes the same instruction set. For example, a program written for one kind of keyboard will not work with another kind of keyboard.

From early on, programmers have taken measures to decrease the dependence of their programs on hardware. The general technique for doing this has been for the programs to deal with the hardware in logical rather than physical terms to the greatest extent possible. The problems posed by the different instruction sets employed by various computer systems have been solved by writing the programs in high-level languages, which deal in logical operations such as assignment of a value to a variable or branching according to the value of a variable rather than in the physical operations performed by a given computer system's instruction set. A compiler program then automatically translates the program written in the high-level language into an equivalent program written in the given computer's instruction set.

Compilers have not, however, been able to solve the problem of dealing with differing peripheral devices. That problem is dealt with at present by the computer system's operating system. An operating system is a computer program that manages the hardware making up a computer system and presents the hardware to the applications programmer as a set of generic entities. The applications programmer thus writes code for a generic keyboard, display, or file system and the operating system deals with the peculiarities of the system's actual keyboards, displays, and file systems. For example, from the point of view of the applications programmer, a keyboard is simply a source of character codes, and the operating system provides the applications programmer with a generic keyboard that is exactly that, while itself dealing with the peculiarities of the particular keyboards being used in the computer system.

FIG. 1 shows a typical computer system 101. Computer system 101 includes a processor 103, memory 111, and a number of peripheral devices 105(0 . . . n). Processor 103 and peripheral devices 105(0 . . . n) are coupled to memory 111 by bus 109, and can thus read data 112 from and write data 112 to memory 111. Processor 103 further reads instructions 114 from programs stored in memory 111 and executes them. Where the program involves peripheral devices, processor 103 responds to the instructions relevant to the peripheral devices by sending control signals to them. When something happens in a peripheral device that requires intervention of processor 103, the peripheral device sends an interrupt to processor 103. In response to the interrupt, processor 103 executes code in memory 111. For example, when a user strikes a key on a keyboard, an interrupt results whose associated code may cause processor 103 to put the character received from the keyboard into a predetermined location in memory for later use by a program that displays characters on a display device.

The programs in memory 111 include one or more applications programs 123, operating system 117, and BIOS 113, a low-level program that provides basic I/O services to operating system 117. BIOS 113, processor 103 and peripheral devices 105(0 . . . n) make up hardware environment 102 of system 101. The makers of hardware environment 102 generally provide a BIOS 113 suited for the environment they are providing.

Operating system 117 makes it possible for applications program 123 to ignore the peculiarities of peripheral devices 105(0 . . . n) and of the interrupts they provide to processor 103. Operating system 117 presents an operating system interface 121 to applications program 123 in which the facilities of computer system 101 appear as generic devices. Thus, a peripheral device 105(i) which is a keyboard appears to application program 123 simply as a source of characters. Operating system 117 is made up of hardware environment-independent code and data 118, which is not affected by the peculiarities of hardware environment 102, and hardware-dependent code and data 119, which is. Two important components of hardware-dependent code and data 119 are device drivers 120 and interrupt handlers 122. A device driver is a program whose code is dependent on the peculiarities of a given peripheral device 105(i), typically because it controls peripheral device 105(i). An interrupt handler is code which processor 103 executes in response to an interrupt from a given peripheral device 105(i). As one would expect, this code is also dependent on the peculiarities of the given peripheral device.

Compilers and operating systems together have made it possible for applications programs to be portable, that is, an application program written for a given operating system can be recompiled to run on any computer system that uses the operating system. However, as one would expect from the role of the operating system in dealing with the hardware environment, operating systems are not portable. Even after the code for an operating system has been recompiled so that it is made up of instructions belonging to processor 103's instruction set, the hardware-dependent code and data 119 must be rewritten to deal with the new hardware environment 102. This process of rewriting the hardware-dependent code and data is termed porting the operating system to the hardware environment. Porting an operating system is difficult, slow, and requires an extensive knowledge of both the new hardware environment 102 and at least the hardware-dependent code and data portion of the operating system.

What is needed is a technique which permits many hardware environments to be presented to the operating system by means of a single generic interface, thereby making it possible to replace the hardware environment-dependent code in the operating system with code that is dependent on the single generic interface, rather than a particular hardware environment. It is an object of the present invention to provide such a technique.

SUMMARY OF THE INVENTION

The invention provides a generic interface layer which executes in a hardware environment and in turn provides a generic interface to the hardware environment to a program such as an operating system that uses the generic interface layer to control and respond to the hardware environment. As mentioned above, the hardware environment includes a number of devices and produces a number of different kinds of interrupts.

The generic interface layer is made up of executable code including driver code for the devices and interrupt handler code which is executed in response to the interrupts. When executed, the interrupt handler code performs callbacks to callback code in the program that is executing on the generic interface layer. The generic interface layer further includes a generic interface to the driver code which the program uses to execute the driver code. In a preferred embodiment, the generic interface is made up of software interrupts, with the program specifying a software interrupt and the generic interface layer responding thereto by executing the corresponding driver code.

Also implemented in the generic interface layer is a loader that will load and begin execution of any program that can execute on the generic interface layer. The loader is able to locate the program in a set of files accessible to the hardware environment, load the program into memory, and set up the hardware environment so that it begins executing the program. The generic interface layer further includes a debugger mode which permits a user of the generic interface layer to control execution of a program running on the generic interface layer.

The generic interface layer uses system clock interrupt code that is executed in response to a system clock interrupt in the hardware environment to coordinate execution of code that does parts of complex operations. Code that executes in the generic interface layer can register itself or other code belonging to the generic interface layer with the system clock interrupt code. When the system clock interrupt code executes in response to the system clock interrupt, it executes the registered code.

One use of this capability is to keep the program that is executing on the generic interface layer from being suspended while the generic interface layer performs an operation which may take considerable time. The operation of course begins with a call by the program being executed by the generic interface layer to a driver; the driver registers a program which performs a component of the operation with the system clock interrupt and returns, thereby permitting the program to continue execution. In response to the next system clock interrupt, the component program is executed; if it can run, it does so, if it cannot, it reregisters itself. It may also of course register a program for another component of the operation. When the operation has been completed, the last component does a callback to the program indicating the result of the operation.

The generic interface layer finally includes an implementation of a technique for managing an array having a fixed number of buffers (0 . . . n) for receiving LAN packets. The LAN packets are stored in a queue of the buffers, with the queue being made up of successive buffers in the array, with buffer (n) being succeeded by buffer (0). If buffer (i) is the head of the queue, buffer (i-1) is always the only buffer in the array whose end-of-buffer bit is set. As the head of the queue moves in the array, the end-of-buffer bit moves with it.

Other objects and advantages will be apparent to those skilled in the arts to which the invention pertains upon perusal of the following Detailed Description and drawing, wherein:

BRIEF DESCRIPTION OF THE DRAWING

FIG. 1 shows a prior-art computer system with an application program, operating system, and hardware environment;

FIG. 2 is a high-level block diagram of an operating system and a generic hardware environment interface layer;

FIG. 3 is a high-level block diagram of the interaction between the operating system, the generic hardware environment interface layer, and a specific hardware environment;

FIG. 4 is a diagram of the memory layout in a preferred embodiment of the generic hardware environment interface layer;

FIG. 5 shows the generic device driver interface in a preferred environment;

FIG. 6 shows an array of LAN packet buffers employed in a preferred embodiment;

FIG. 7 is a conceptual block diagram of loader 318;

FIG. 8 is a flowchart of the ResetLAN software interrupt;

FIG. 9 is a flowchart of the system timer interrupt handler in a preferred embodiment; and

FIG. 10 is a flowchart of an operation executed by GHE layer 201 in the course of resetting the LAN controller.

Reference numbers in the drawing have three or more digits: the two right-hand digits are reference numbers in the drawing indicated by the remaining digits. Thus, an item with the reference number 203 first appears as item 203 in FIG. 2.

DETAILED DESCRIPTION

The following Detailed Description will first present an overview of the invention and will then present a detailed description of a preferred embodiment.

Overview of the Invention: FIGS. 2 and 3

FIG. 2 shows memory 111 in a computer system that uses the invention to reduce the effort of porting an operating system to a new hardware environment. As before, memory 111 includes an application program 123, a bios 113, and an operating system 203. However, the hardware-dependent code and data 119 of operating system 107 has been replaced by generic hardware environment code and data 207 and a new element has been added: generic hardware environment layer 201. Generic hardware environment code and data 207 no longer contains device drivers or interrupt handlers; these are now found at 206 and 208 in generic hardware environment layer 207. As before, device drivers 206 and interrupt handlers 208 are specific to a given hardware environment 102. Generic hardware interface layer 201 presents generic interfaces 205 to operating system 203 for the device drivers 206 and the interrupt handlers 208. Thus, as long as there is a generic hardware environment layer 201 for a given hardware environment 102, an operating system such as operating system 203 that uses the generic interfaces 205 will work with that hardware environment.

When an operating system uses a generic hardware interface layer 201, it is the generic hardware environment layer 201, instead of the operating system, that must be ported to a new hardware environment. Generic hardware environment layer 201 is much simpler than an operating system, and porting it is consequently easier. Moreover, since generic hardware environment layer 201 offers generic device driver and interrupt handling facilities to the operating system, the programmers who port generic hardware environment layer 201 to a new hardware environment need know nothing whatever about the operating system to do the porting.

FIG. 3 shows the interaction between generic hardware environment layer 201, operating system 207, and hardware environment 102 in a preferred embodiment. The code for generic hardware environment layer 201 is executed by the same process that executes GHE-dependent code and data 207 and data used by both generic hardware environment layer 201 and GHE-dependent code and data 207 is in a portion of that process's address space which is accessible to both generic hardware environment layer 201 and GHE-dependent code and data 207.

Execution of the code in generic hardware environment layer 201 is interrupt driven, that is, processor 103 executes programs in generic hardware environment layer 201 in response to interrupts or exceptions from components of computer system 101. There are two sources for such interrupts or exceptions: the hardware components of hardware environment 102, which produce what will be termed herein device interrupts 321, and execution of programs, which produce software interrupts 319. Included in the instructions executed by processor 103 is a software interrupt instruction; when processor 103 executes a software interrupt instruction, it behaves exactly as if it had received an interrupt from a component of hardware environment 102. All device interrupts 321 produced by hardware environment 102 are handled by generic hardware environment layer 201 instead of by operating system 207; as will be explained in more detail later, operating system 207 uses software interrupts to invoke the device drivers 206 in generic hardware environment layer 201.

Processor 103 responds to a given interrupt or exception by executing an exception handler or interrupt handler program such as those shown at 122 and 208. The interrupts and exceptions are related to their handler programs by interrupt gates, shown at 309. For a given interrupt, there is an interrupt gate 309(i) corresponding to the interrupt. Included in interrupt gate 309(i) for the interrupt is a specifier from which the interrupt handler for the interrupt can be located. Thus, when processor 103 receives an interrupt, it finds gate 309(i) corresponding to the interrupt and uses the specifier to locate the interrupt handler for the interrupt. Thereupon, processor 103 executes the interrupt handler. Also included in the instructions executed by processor 103 are instructions which disable and enable interrupts; when an interrupt is disabled, processor 103 does not respond to an occurrence of the interrupt, and consequently, the interrupt handler is not executed. These instructions can disable individual interrupts or can disable all interrupts.

In addition to receiving software interrupts from operating system 203, generic hardware environment layer 201 makes callbacks to operating system 203. Callbacks are a way of dynamically making code in one program available to another program. Here, the code is callback dispatcher 305. To make callback dispatcher 305 available to generic hardware environment layer 201, operating system 203 registers the function with GHE layer 201 by providing GHE layer 201 a pointer to the function. After the function is registered, the interrupt handlers 317 for all of the interrupt gates 313 for the hardware interrupts call callback dispatcher 305; thus, whenever a device interrupt 312 occurs, the result is a callback to callback dispatcher 305.

GHE layer 201 thus uses callback dispatcher 305 to indicate to operating system 203 that a given device interrupt or exception has taken place and to provide information about the interrupt or exception to operating system. More particularly, when an interrupt handler 317(i) makes the callback to callback dispatcher 305, it provides an identifier for the interrupt or exception, information about the interrupt or exception, and a pointer to machine register state which GHE layer 201 saved when the interrupt or exception occurred. Callback dispatcher 305 then calls a handler function 303 corresponding to the interrupt specified by the identifier and the handler function uses the information about the interrupt and the saved state to do whatever processing is necessary at the operating system level.

Together, the software interrupts and information provided to callback dispatcher 305 make up generic hardware environment interface 205. Device drivers are specified in the software interrupts by the numbers of the gates 311 in gates 309. Each of these gates has associated with it a driver 315 for one of the devices. To use a given device driver, operating system 203 simply does a software interrupt specifying that driver and passes the driver generic information that it needs to deal with the device. Operating system 203's interface to the device drivers is thus completely independent of the actual device drivers 315 for the particular hardware environment 102 and therefore of hardware environment 102. Operating system 203's interface to the device drivers appears as GHEI SW interrupts 301(i . . . n) in FIG. 3 For example, to get a character from serial character device such as a keyboard, the operating system simply specifies the gate for the serial character device driver and the number of the serial port to which the keyboard is connected. Similarly, as indicated above, with each callback, operating system 203 gets a handle indicating the interrupt or exception, further information about the interrupt or exception, and a pointer to the state saved when the interrupt or exception occurred. What the handler functions 303 receive in operating system 203 is thus completely independent of the details of the devices that generated the interrupts.

Overview of Operation of Generic Hardware Environment Layer 201

Operation of generic hardware environment layer 201 will be shown using the example of input from a typewriter keyboard. When the user of the keyboard presses a key, the character code for the character represented by the key is placed in a queue in memory accessible to processor 103 and the keyboard sends an interrupt to processor 103. The gate for the interrupt is in GHE hardware interrupt gates 313, so processor 103 executes an interrupt handler 317 which in turn calls callback dispatcher 305. The call's arguments include an identifier for the serial character interrupt, the port number on which the interrupt occurred, and the state that was saved when the interrupt occurred. Callback dispatcher 305 invokes handler function 303(i) for the serial character interrupt using the port number. Hander function 303(i) in turn issues the software interrupt specifying driver 315(i) for reading from serial character devices and the port number. When the software interrupt occurs, the result is the execution of driver 315(i), which reads the character at the head of the queue belonging to the port and returns it to handler function 303(i), which in turn provides it to the program which is receiving input from the keyboard and returns. Callback dispatcher 305 then returns, and GHE layer 201 remains inactive until the next hardware or software interrupt occurs.

Details of a Preferred Embodiment

The generic HE layer 201 of the invention was developed to simplify porting an operating system originally written for Motorola 88000 hardware to a hardware environment which employed an Intel Pentium(g processor and which was specialized for high-speed access to a local-area network (LAN) and an array of disk drives that obey the SCSI protocol.

Memory Arrangement in a Preferred Environment: FIG. 4

FIG. 4 is a detail of system memory 401 for operating system 203 and generic HE layer 201. At the top of system memory 401 is memory 403 reserved for OS 203; then comes memory 415 which is shared by both generic HE layer 201 and OS 203; at the bottom of system memory 401 is memory 417 for data private to generic HE layer 201, memory 419 for generic HE layer 201's code, and memory 421 for BIOS 113 and the bootstrap code needed to get the system running.

OS and GHE layer shared memory 415 includes areas for storing state for the programs that are executed in consequence of the interrupts received in GHE layer 201, areas for storing data needed for the LAN operations, and areas for storing system configuration information. Beginning with GHE layer stack 405, device drivers 206, interrupt handlers 317, callback dispatcher 305, and handler functions 303 all execute on GHE layer stack 405. Each time GHE layer 201 responds to an interrupt, it saves the current state of certain registers in processor 103 in interrupt state save area 407, where the state is available for examination and limited modification by the handler function 303 that is invoked as a result of the callback made in response to the interrupt. On return from the driver 315 or callback 305 executed in response to the interrupt, GHE layer 201 restores the saved state. If the saved state has been modified, GHE layer 201 restores the modified state. In a preferred environment, GHE layer 201 disables interrupts when it responds to either a software or hardware interrupt. Some interrupts, however, cannot be disabled. To deal with this problem, GHE layer 201 includes sufficient storage in interrupt state save area 407 for register state from three interrupts.

LAN buffers 409 store data that is output to or has been received from the LANs that are part of hardware environment 102. Free space 411 is exactly that, and is available generally for information to be shared between GHE layer 201 and operating system 203. LAN stats and system configuration tables 413 contain statistical and configuration information needed by both GHE layer 201 and operating system 203.

The Generic Device Driver Interface in a Preferred Environment: FIG. 5

FIG. 5 shows the generic device driver interface for the preferred embodiment. Each device driver is associated with an interrupt gate 309, and table 501 shows the relationship between the drivers and the interrupt gate. A call to a device driver is made by pushing any arguments required for the device driver onto a frame in operating system 203's stack and then copying the arguments onto GHE layer stack 405 and issuing a software interrupt instruction for the interrupt gate number 309(i) associated with the device driver. For example, the generic device driver interface for sending serial characters is SendSerialChar, shown at 519. Two arguments are required: the port number for the serial port from which the serial character is to be sent and the character itself. Code in GHE dependent code and data 207 that sends a serial character will first push the arguments onto the stack frame and then issue a software interrupt instruction with the gate number 78.

Continuing with the functions of table 501 in more detail, SetCallBack 507 provides the information needed to call callback dispatcher 305 to the interrupt handlers 317. ReturnToScm 509 is a software interrupt which places GHE layer 201 in a debugging mode. The functions listed at 511 are for simple character I/O, with output going to a character monitor and input coming from a keyboard. They are used for debugging. GetSystemConfiguration obtains current configuration information about hardware environment 102. The information is contained in a buffer accessible to GHE layer 201. The following table shows the information:

        Value                                         Offset
        Interface revision number                     0x0000
        Implementation revision number                0x0002
        Number of SCSI buses                          0x0004
        Configured serial ports                       0x0006
        (bit field, bit 0 - COM1, bit 1 - COM2, if bit value is
        set ("1") COM port is configured, if bit value is clear
        ("0") COM port is not configured.)
        Memory size in bytes                          0x0008
        Processor clock frequency in Hz               0x000C
        Pointer to boot string used to boot operating system 0x0010
        203, null-terminated
        Pointer to the default LAN MAC address        0x0014
        (value is stored as 6 unsigned characters)
        Pointer to the current LAN MAC address        0x0018
        (value is stored as 6 unsigned characters)

        Value                                       Offset
        SCSI Bus number                             0x0000
        Target Id                                   0x0001
        Target LUN                                  0x0002
        CDB size - 6, 10, or 12                     0x0003
        CDB pointer                                 0x0004
        Buffer size - provided by OS 203            0x0008
        Buffer pointer - provided by OS 203         0x000C
        SCSI status - filled in by GHE layer 201 before 0x0010
        callback
        Sense data size - provided by OS 203        0x0014
        Sense data pointer - filled in by GHE layer 201 0x0018
        before callback

                  Saved register           Offset
                  EAX                      0x0000
                  EDX                      0x0004
                  ECX                      0x0008
                  EBX                      0x000C
                  EBP                      0x0010
                  ESI                      0x0014
                  EDI                      0x0018
                  ESP                      0x001C
                  Eflags                   0x0020
                  EIP                      0x0024

    Register Name              Note
    EAX, EBX, ECX, EDX         read/write
    EBP, ESI, EDI, ESP         read/write
    EIP                        read/write
    CS, DS, ES, FS, GS         read only
    EFLAGS                     partial read/write (some bits cannot
                               be altered to protect the state of GHE
                               layer 201
    CR0, CR2, CR3, CR4         read only
    DR0, DR1, DR2, DR3, DR6,   read/write (Note: these are the debug
    DR7                        registers provided in the P6 chip to
                               support traps on read/write
                               operations. The register values are
                               modified by the break and clear
                               commands. Arbitrary changes by the
                               reg command of these registers can
                               make the information shown by the
                               break command invalid.)

          Offset          Description
          0x0             exception number
          0x4             next context block address
          0x8             eax
          0xC             edx
          0x10            ecx
          0x14            ebx
          0x18            ebp
          0x1C            esi
          0x20            edi
          0x24            esp
          0x28            copy of eflags
          0x2C            copy of eip
          0x30            gs (16 bit value)
          0x32            fs (16 bit value)
          0x34            es (16 bit value)
          0x36            ds (16 bit value)
          0x38            arg0
          0x3C            arg1
          0x40            halt condition
          0x44            GHE 201 layer pre handler return addr
          0x48            error code
          0x4C            eip
          0x50            cs (16 bit value)
          0x52            pad (16 bit value)
          0x54            eflags
          0x58            pad value

• Inventors
  Burriss, Michael Lee; Worth, III, Stephen Gardner; Huff, Jerry W.; Bong, Paul A.;
• Assignee
  EMC Corporation (Hopkinton, MA)
• Published
  Jul-20-2004
• Current US Classes:
  719/321
  719/328
• Application #
  277414
• International Classes
  G06F 013/10
• Field of Search
  709/321 709/328 709/327 719/321
• Examiner
  An; Meng-Al T.
• Agent
  Nelson; Gordon E.
• US Patent References:
  5454110
  5790846
  5809303
  6253320
  6381682