American Megatrends, Inc.

American Megatrends International, LLC

Amencan Megatrends, Inc.

Feliks Polyudov

Sergiy Yakovlev

Bejean David Mosher

Senthamizhsey Subramanian

Srinivasan Narayana Rao

A computing device includes a processor, a volatile memory, and a non-volatile memory. The computing device receives a firmware update that includes updated firmware runtime components, such as updated runtime interrupt handlers (e.g. SMI handlers). The computing device stores the updated firmware runtime components in the volatile memory (e.g. RAM) of the device. The computing device also causes the updated firmware runtime components stored in the volatile memory to be used during the runtime of the computing device instead of one or more other firmware runtime components previously stored in the volatile memory. For example, the contents of one or more interrupt routing tables can be adjusted such that updated runtime interrupt handlers stored in volatile memory are used instead of previously installed and potentially insecure runtime interrupt handlers. On a subsequent reboot of the computing device, updated firmware runtime components stored in the non-volatile memory will be utilized.

Updating firmware runtime components

A first firmware component executes from a secure memory and a second firmware component executes from a non-secure memory. The first firmware component receives a request to store data in a non-volatile (NV) memory. In response to the request, the first firmware component stores the data in the NV memory and in a buffer located in the secure memory. The first firmware component also copies the buffer to non-secure memory. The first firmware component provides an indication to the second firmware component that the buffer was updated. The second firmware component can then update an internal data structure identifying the start, end, or size of the data stored in the buffer. Once the internal data structure is updated, the second firmware component can respond to requests to retrieve firmware variables of other types of data without accessing buffers in secure memory.

Performant and secure storage and retrieval of firmware variables

A method for storing a data file associated with a source code file of a firmware program in an EFI environment is provided. The method involves converting the data file to an object file as well as converting the firmware source code file to an object file. An executable file is then created from the object file of the data file and the object file of the firmware source code file. Once created, the executable file may be stored in a file of a firmware storage device.

Method, apparatus, and computer-readable medium for storing data associated with a firmware program

Methods, apparatus, and computer-readable media for executing the same program module in a PEI phase and a DXE phase are disclosed. According to one method, a program module is first executed in the PEI phase. While the program module is executing in the PEI, it stores the memory address of a DXE entry point in a hand-off block. When the DXE phase is entered, the stored DXE entry point for the program module is retrieved from the hand-off block and the program module is executed at the DXE entry point.

Execution of a program module within both a PEI phase and a DXE phase of an EFI firmware

Firmware is interactively recoverable prior to loading an operating system on a computer. Rather than proceeding through a recovery without user input, user input about a recovery is solicited after determining that an update is needed. Prior to recovering the firmware, users may be able to, for example, specify configuration options about the recovery, cancel the update altogether, and specify a firmware image location. Once input is received, the firmware recovery proceeds.

Interactive firmware recovery

The routines to be called by the dispatching function are identified based on the contents of description files associated with the child modules containing the routines to be called. Once the routines to be called by the dispatching function have been identified, an initialization source file is generated that includes source program code for calling each of the identified routines. Once the initialization source file has been generated, the parent program module is built by compiling the individual routines to generate object code and then linking the compiled files to generate the parent program module. The resulting executable parent program module includes the proper calls to execute the identified routines.

Method, apparatus, and computer-readable medium for generating a dispatching function

An efficient PEIM-to-PEIM interface ('PPI') database for storing data identifying one or more PPIs. The PPI database includes a linked list having one or more linked arrays of elements. The elements in each array store data identifying a PPI. Each array in the linked list of arrays may also include an element reserved for storing data identifying the last element in the array. Each array in the linked list of arrays may also include an element reserved for storing a pointer to a next array in the linked list of arrays. When the last array in the linked list of arrays becomes full, a new array is created, and a pointer to the new array is stored in the last array.

Memory efficient peim-to-peim interface database

Methods, apparatus, and computer-readable media for providing a device handle database in an EFI environment are disclosed. According to one method, a device handle database is created for storing data identifying the protocols that have been installed on one or more device handles. The database includes a sorted array of elements utilized to store protocol data for a family of protocols having the same GUID. Each element in the array comprises a family data structure including a field for storing the GUID for the family along with a field for storing a pointer to a linked list that stores the protocol instance data for each of the protocols in the family. Each node in the linked list is also a member of a linked list for storing protocol data for all of the protocols installed on a given device handle.

Database for storing device handle data in an extensible firmware interface environment

Firmware is interactively updatable in a setup facility prior to loading an operating system on a computer. A computer repeatedly provides progress information during the course of a firmware update. This progress information may be in the form of a repeatedly updated completion percentage displayed on a screen during the update.

Interactive pre-OS firmware update with repeated disabling of interrupts

Methods, apparatus, and computer-readable media for relocating a program module executing within a PEI phase from a NVRAM to a RAM are provided. According to one method, a program module is executed from NVRAM prior to RAM being initialized in the PEI phase. While the program module is executing from the NVRAM, it is operative to store an in-memory entry point in a hand-off block. When the RAM is initialized and becomes available in the PEI phase, the in-memory entry point for the module is retrieved from the hand-off block. The RAM address of the in-memory entry point is then calculated, and the program module is executed from the RAM at the calculated in-memory entry point.

Relocating a program module from NVRAM to RAM during the PEI phase of an EFI-compatible firmware

A method is provided for simultaneously updating the contents of multiple memory devices in a computer system. The contents of each of the memory devices are organized as a series of blocks. One of the memory devices is selected as a current device. A determination is then made as to whether the blocks of the current device need to be updated. The blocks of the current device are updated until a memory wait state is generated by the current device. In response to the memory wait state being generated by the current device, a determination is made as to whether the blocks contained in any of the other memory devices remain to be updated. If there are blocks in any of the other memory devices remaining to be updated, a next memory device is identified having blocks to be updated. The identified memory device is then selected as the current device. Finally, the steps of the method are repeated for each current device until all of the blocks contained in each of the multiple memory devices have been updated. The memory devices may be utilized to store a basic input/output system (BIOS) for the computer system.

Method, system, and computer-readable medium for updating memory devices in a computer system

Methods, apparatus, and computer-readable media for executing the same program module in a PEI and ad DXE are disclosed. According to one method, a program module is first executed in the PEI phase. While the program module is executing in the PEI, it stores the memory address of a DXE entry point in a hand-off block. When the DXE phase is entered, the stored DXE entry point for the program module is retrieved from the hand-off block and the program module is executed at the DXE entry point.

Methods, systems, and computer-readable media are provided for efficiently evaluation Boolean expressions. According to the method, the Boolean expression is expressed using pre-fix notation. Each element in the pre-fix expression is then parsed. For each first operand for a Boolean operation, the value of the operand is determined. This may include evaluating a GUID. When an operator and a second operand are encountered, a decision is made as to whether the second operand should be evaluated. The determination as to whether the second operand should be evaluated is made based upon the value of the first operand and the type of operator. If the second operand need not be evaluated, no evaluation is performed thereby saving time and memory space. The evaluation of the Boolean expression continues in this manner until the entire expression has been evaluated. If the Boolean expression is evaluated as true, the program module associated with the Boolean expression may be loaded. Otherwise, the program module will not be loaded.

Growing community of inventors

Lilburn, GA, United States of America

Feliks Polyudov