US20030135534A1 - Method and apparatus for generating SMI from ACPI ASL control code to execute complex tasks - Google Patents
Method and apparatus for generating SMI from ACPI ASL control code to execute complex tasks Download PDFInfo
- Publication number
- US20030135534A1 US20030135534A1 US10/039,054 US3905401A US2003135534A1 US 20030135534 A1 US20030135534 A1 US 20030135534A1 US 3905401 A US3905401 A US 3905401A US 2003135534 A1 US2003135534 A1 US 2003135534A1
- Authority
- US
- United States
- Prior art keywords
- smi
- smm
- processor
- acpi control
- instructions
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 56
- 230000004044 response Effects 0.000 claims description 12
- 230000008569 process Effects 0.000 claims description 11
- 238000001514 detection method Methods 0.000 claims description 4
- 238000010586 diagram Methods 0.000 description 4
- 238000012546 transfer Methods 0.000 description 4
- 238000012545 processing Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 2
- 230000006870 function Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4812—Task transfer initiation or dispatching by interrupt, e.g. masked
Definitions
- the present invention relates generally to computer systems and more particularly microprocessor based computer systems.
- ACPI Advanced Configuration and Power Interface
- OS operating system
- AML ACPI Machine Language
- BIOS support code does not determine the policies of time-outs for power or resource management. Rather, these policies are determined by the operating system.
- the ACPI hardware interface provides functionality to the OS in (i) control/detection of system control tasks using a normal interrupt called System Control Interrupt (“SCI”), rather than a System Management Interrupt (“SMI”), and (ii) control of the system power state.
- SCI System Control Interrupt
- SMI System Management Interrupt
- the details of a platform's support for the hardware interface are provided in a set of well-defined tables within the system BIOS.
- the ACPI software interface provides the means for the OS to find the different ACPI related tables in the system BIOS and means for the OS to understand and control the characteristics of the motherboard using AML.
- AML resides in the tables within the system BIOS.
- ACPI source language (ASL) is the preferred source language for writing ACPI control methods. Most OEMS and BIOS developers write control methods in ASL.
- a translation tool translates ASL code to AML code versions of the control methods.
- AML is the ACPI control method virtual machine language, i.e., a machine code for a virtual machine that is supported by an ACPI-compatible OS. It is a pseudo-code assembly language that is interpreted by an OS driver.
- AML is the language processed by the ACPI method interpreter. It is primarily a declarative language and provides a set of declarations that is compiled by the ACPI interpreter into the ACPI name space at definition block load time.
- AML's access to memory, I/O and PCI configuration space is either static or the capabilities provided for dynamic values are so limited as to be useless in may situations. It is thus very difficult for code developers to develop optimal code that can execute fast and hence positively affect performance.
- FIG. 1 illustrates a functional block diagram of an embodiment of an exemplary computer system embodying the present invention.
- FIG. 2 illustrates an embodiment of a process for enabling a control method executed by the operating system to invoke a SMI from within ACPI code after a complex task has been detected.
- FIG. 3 illustrates a flow diagram of an embodiment of a process for enabling a control method executed by the operating system under ACPI control to handle tasks, including complex tasks.
- Embodiments of the present invention provide for generation of SMI from ACPI ASL control method code to execute complex tasks including, but not limited to, transferring or searching through large amounts of data dynamically.
- a SMI is generated in an ASL code execution path to enable usage of a flexible native central processor unit (CPU) instruction set accessible to a system management mode (SMM) handler.
- CPU central processor unit
- SMM system management mode
- an operation region is defined for a SMI generation I/O register.
- the Pre-OS software configures the chipset to generate an SMI when an I/O access occurs to this particular address location defined through the ACPI Operation Region.
- An ACPI control method execution by any OS entity accesses the SMI generation I/O register to generate an SMI during ASL code execution when a predefined complex task is encountered, thus enabling the SMI handler code to advantageously execute the complex task.
- FIG. 1 illustrates a functional block diagram of an embodiment 100 of an exemplary computer system implementing an ACPI system 102 .
- AML is a virtual machine language, compiled from ASL, in which device control methods are written, and which is understandable to all ACPI-compatible operating systems. Device control methods are typically written by device manufacturers and provided to platform developers and manufacturers.
- Operating system dependent software applications 104 run on a system interface, through kernel 106 with operating system control code 108 and ACPI driver/machine language interpreter 110 .
- Operating system control code 108 and ACPI driver/machine language interpreter 110 operate in software within microprocessor (not shown), and are operating system specific.
- Kernel 106 also interfaces with device driver 112 , also running in software on the microprocessor.
- ACPI driver/machine language interpreter 110 software interfaces with ACPI registers 114 , ACPI Basic Input Output System (BIOS) 116 , and ACPI tables 118 , to platform hardware 120 and, through platform hardware 120 , to system BIOS 122 .
- ACPI machine language AML is a machine language capable of interfacing between any ACPI aware operating system and any system Basic Input Output System function. ACPI is intended to interface between hardware and software, though the requirements of the ACPI environment may be viewed in many respects as a hardware specification.
- Device driver 112 allows interface with the platform hardware.
- ACPI tables 118 describe the interface to the hardware. Although some controls are embedded in fixed blocks of registers, ACPI tables 118 specify the addresses of the register blocks. When the operating system executes p-code, ACPI tables 116 can be accessed.
- FIG. 2 illustrates an embodiment of a process for enabling a control method executed by the operating system to invoke a SMI from within ACPI code after a complex task has been detected.
- the OS identifies an ACPI related activity that needs to be executed on behalf of some device/driver entity, the task is routed and targeted to the appropriate components of the OS ACPI driver.
- ACPI driver 110 queues control methods to handle each task (step 204 ). In particular, the ACPI driver 110 accesses the control method and device driver of the device.
- the present invention detects tasks that are more suitably processed by SMI handler code based on the particular tasks detected in the tasks registers. In an ACPI environment, such transfers are within the management control of the operating system, yet the AML code limitations affect efficient execution of certain complex tasks.
- Complex tasks suitable for the SMI handler include, but are not limited to, handling and transferring large amounts of data that has to be gathered dynamically during runtime, saving and restoring devices coming out of suspend state, determining device standards, accessing features not accessible to the ASL code and so forth.
- Complex tasks requiring transfer or search of large bodies of data are particularly problematic, since the AML access to memory, I/O and PCI configuration space is either static or else the capabilities provided for dynamic values are so limited as to be largely useless. This makes it difficult for code developers to develop optimal code that can execute fast and hence positively affect performance.
- ROM images need to be copied from a flash component to memory area.
- a SMI is generated by the control code and a SMI handler correspondingly copies the flash component to the memory area. After the task is completed, control is transferred back to ASL code.
- One skilled in the art will recognize that embodiments of the present invention can be configured to allow the control method to generate an SMI interrupt and consequently enable SMI handler code to handle any kind of tasks, including those which may be handled readily by the ASL code as well.
- ACPI table 118 is a collection of registers.
- the status registers are software readable by ACPI driver 110 . These are also hardware readable in the context that the hardware can read the status bit in order to determine whether to generate a SMI.
- the base address of the task register and the lengths of the task blocks are all defined in ACPI table 118 . In accordance with the ACPI specification, between zero and 255 task inputs can be implemented.
- the task status register containing the task status bits, thus allows 255 tasks (i.e., status register values).
- a SCI arbiter Upon receiving a task that is identified as handled using ASL capabilities, a SCI arbiter accesses ACPI driver 110 , which either passes control to an ACPI-aware driver, or uses a manufacturer-supplied control method or device driver 112 , to handle the task.
- ACPI driver 110 determines which status bit, among the status bits in the task register, is asserted. As indicated above, each status bit, and its corresponding enable bit, is hard-wired and dedicated to receive a particular task. The selection of a control method or device driver 112 is determined by which bit received the signal indicating the task.
- the control method invokes a SMI from within ACPI code to handle operations in an optimal way (step 206 ).
- the chipset has a capability to generate an SMI based on accesses to predefined I/O address locations.
- the control method accesses the I/O address location that is programmed to trigger an SMI by using the chipset capability.
- An SMI is generated in the path of ASL code execution to enable usage of flexible native CPU instruction set within the SMI handler.
- a software SMI generation I/O register access is used to force an SMI occurrence within the ASL code execution path.
- an operation region is defined for the SMI I/O address that is being accessed. Once an operation region is defined for an I/O address, this newly defined entity can be accessed from within any of the control methods to generate an SMI.
- the control method performs whatever action is appropriate for the task it handles. For example, if the task requires complex data handling and transfer, the control method acknowledges the task as one handled by a SMI handler.
- ACPI driver 110 detects the assertion of an enable bit of the task register, it calls the appropriate driver 112 according to the particular task register pin asserted and according to ACPI table 118 . If the task register pin and table 118 indicate that the task should be handled by SMM code, an SMI is generated within the ACPI code and the SMI handler handles the task.
- the operating system sets the SMI enable bit for the device in the SMI generation I/O register when a complex task is detected.
- the SMI handler then processes the complex task (step 208 ).
- Embodiments of the present invention thus identify and redirect complicated tasks in the ACPI ASL code to the SMM. In this manner, some or all of the complicated tasks handled by the ACPI ASL code are instead handled by the SMM.
- the processor stops and processes the SMI.
- An SMI handler is given control for the various processors at different address locations. Each processor SMI handler starts executing its code once it has been invoked.
- the SMI handler code gets various tasks that have to be executed through the I/O address contents. In this regard, the SMI handler takes the appropriate code path to handle complicated tasks for which it has been invoked.
- the data can be easily gathered from within the SMI handler code instead of writing complex ACPI ASL code.
- the SMI handler By allowing the SMI handler to handle complicated tasks, the difficulties associated with using ACPI ASL code is minimized.
- the same data transfer can now occur faster during runtime OS execution by using the processor's powerful instruction set capability and in some cases having multiple processors being available for data processing allows for good delegation of tasks between the processing power that is available on the platform.
- SMM is invoked by generating a SMI signal to processor.
- Processor in response, asserts the SMI control signal that accesses a SMRAM region.
- the current processor state i.e. context
- processor then jumps to a location in SMRAM to execute the extended SMI handler code for the complex task.
- the SMI handler Upon completion of the complex task, the SMI handler executes a resume (RSM) instruction that restores processor's context from SMRAM, de-asserts the SMI signal, and then returns control to the control method under ACPI ASL code (steps 206 , 204 and 202 ).
- RSM resume
- ACPI ASL code ACPI ASL code
- FIG. 3 illustrates a flow diagram of an embodiment 300 of a process for enabling a control method executed by the operating system under ACPI control to handle tasks, including complex tasks.
- the processor along with a memory includes a software routine that, during runtime, detects the assertion of a signal on the task register bit connected to the device. The assertion of the signal on the task register bit and then determination that the task comprises a complex task suitable for execution by the SMI handler, calls the software routine.
- the software routine obviates the need for the ACPI ASL code to execute complex instructions more suitable for the SMI handler to execute. Enable bits are read and written by software, and indicate to the system whether a task occurrence from a particular device is to be executed by the SMI handler instead.
- ACPI driver 110 queues control methods to handle each task (step 304 ).
- the control method invokes a SMI from within ACPI code to handle operations in an optimal way (step 308 ).
- the ACPI control method accesses the I/O address location that triggers an SMI signal to the processor by using the chipset capability.
- a SMI is generated in the path of ASL code execution to enable usage of flexible native CPU instruction set within the SMI handler.
- the SMI handler then processes the complex task (step 310 ).
- Embodiments of the present invention thus identify and redirect complicated tasks in the ACPI ASL code to the SMM.
- the SMI handler Upon completion of the complex task, the SMI handler executes a resume (RSM) instruction that restores processor's context from SMRAM, de-asserts the SMI signal, and then returns control to the control method under ACPI ASL code (steps 312 , 314 ).
- RSM resume
- ACPI ASL code ACPI ASL code
- step 306 If a complex task is not detected (step 306 ), then processing is continued under ASL control (step 314 ) and a SMI is not generated.
- a task occurrence from a hardware device sets a status bit, corresponding to the device status bits are set in hardware, and are read both by hardware in order to cause the SCI task occurrence.
- the enable bit corresponding to that status bit (and to the device) may be set as well.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
- Executing Machine-Instructions (AREA)
Abstract
Description
- 1. Field
- The present invention relates generally to computer systems and more particularly microprocessor based computer systems.
- 2. Background Information
- Advanced Configuration and Power Interface (ACPI) is an extensible tool by which the operating system (OS) can be given greater control over power and resource management functions in computer systems, such as personal computers. ACPI provides a hardware and software interface by which an OS can manipulate the characteristics of motherboard devices. This technology differs from existing Basic Input/Output System (“BIOS”) technologies in at least two regards: (i) the BIOS support code is written in p-code called ACPI Machine Language (“AML”), rather than in the native assembly language of a platform; and (ii) the BIOS support code does not determine the policies of time-outs for power or resource management. Rather, these policies are determined by the operating system.
- The ACPI hardware interface provides functionality to the OS in (i) control/detection of system control tasks using a normal interrupt called System Control Interrupt (“SCI”), rather than a System Management Interrupt (“SMI”), and (ii) control of the system power state. The details of a platform's support for the hardware interface are provided in a set of well-defined tables within the system BIOS. The ACPI software interface provides the means for the OS to find the different ACPI related tables in the system BIOS and means for the OS to understand and control the characteristics of the motherboard using AML. AML resides in the tables within the system BIOS. ACPI source language (ASL) is the preferred source language for writing ACPI control methods. Most OEMS and BIOS developers write control methods in ASL. A translation tool translates ASL code to AML code versions of the control methods.
- AML is the ACPI control method virtual machine language, i.e., a machine code for a virtual machine that is supported by an ACPI-compatible OS. It is a pseudo-code assembly language that is interpreted by an OS driver. AML is the language processed by the ACPI method interpreter. It is primarily a declarative language and provides a set of declarations that is compiled by the ACPI interpreter into the ACPI name space at definition block load time. However, AML's access to memory, I/O and PCI configuration space is either static or the capabilities provided for dynamic values are so limited as to be useless in may situations. It is thus very difficult for code developers to develop optimal code that can execute fast and hence positively affect performance.
- What is needed therefore is a method and apparatus for controlling code execution in a mode where a whole range of native CPU instructions can be executed.
- FIG. 1 illustrates a functional block diagram of an embodiment of an exemplary computer system embodying the present invention.
- FIG. 2 illustrates an embodiment of a process for enabling a control method executed by the operating system to invoke a SMI from within ACPI code after a complex task has been detected.
- FIG. 3 illustrates a flow diagram of an embodiment of a process for enabling a control method executed by the operating system under ACPI control to handle tasks, including complex tasks.
- In the following description, numerous specific details are set forth such as specific memory configurations, address ranges, protection schemes, etc., in order to provide a more thorough understanding of the present invention. It will be apparent, however, to one skilled in the art, that the present invention may be practiced without these specific details. In other instances, well known apparatus and process steps have not been described in detail in order to avoid obscuring the invention.
- Embodiments of the present invention provide for generation of SMI from ACPI ASL control method code to execute complex tasks including, but not limited to, transferring or searching through large amounts of data dynamically. Instead of executing certain tasks using limited ASL functionality, a SMI is generated in an ASL code execution path to enable usage of a flexible native central processor unit (CPU) instruction set accessible to a system management mode (SMM) handler. In particular, an operation region is defined for a SMI generation I/O register. The Pre-OS software configures the chipset to generate an SMI when an I/O access occurs to this particular address location defined through the ACPI Operation Region. An ACPI control method execution by any OS entity accesses the SMI generation I/O register to generate an SMI during ASL code execution when a predefined complex task is encountered, thus enabling the SMI handler code to advantageously execute the complex task.
- FIG. 1 illustrates a functional block diagram of an
embodiment 100 of an exemplary computer system implementing anACPI system 102. AML is a virtual machine language, compiled from ASL, in which device control methods are written, and which is understandable to all ACPI-compatible operating systems. Device control methods are typically written by device manufacturers and provided to platform developers and manufacturers. - Operating system
dependent software applications 104 run on a system interface, throughkernel 106 with operatingsystem control code 108 and ACPI driver/machine language interpreter 110. Operatingsystem control code 108 and ACPI driver/machine language interpreter 110 operate in software within microprocessor (not shown), and are operating system specific.Kernel 106 also interfaces withdevice driver 112, also running in software on the microprocessor. - Through ACPI driver/
machine language interpreter 110, software interfaces with ACPIregisters 114, ACPI Basic Input Output System (BIOS) 116, and ACPI tables 118, toplatform hardware 120 and, throughplatform hardware 120, tosystem BIOS 122. ACPI machine language (AML) is a machine language capable of interfacing between any ACPI aware operating system and any system Basic Input Output System function. ACPI is intended to interface between hardware and software, though the requirements of the ACPI environment may be viewed in many respects as a hardware specification. -
Device driver 112 allows interface with the platform hardware. ACPI tables 118 describe the interface to the hardware. Although some controls are embedded in fixed blocks of registers, ACPI tables 118 specify the addresses of the register blocks. When the operating system executes p-code, ACPI tables 116 can be accessed. - FIG. 2 illustrates an embodiment of a process for enabling a control method executed by the operating system to invoke a SMI from within ACPI code after a complex task has been detected. When the OS identifies an ACPI related activity that needs to be executed on behalf of some device/driver entity, the task is routed and targeted to the appropriate components of the OS ACPI driver. Under OS runtime execution (step202), ACPI driver 110 queues control methods to handle each task (step 204). In particular, the ACPI
driver 110 accesses the control method and device driver of the device. Unlike conventional interrupt-handling ACPI-compatible hardware that relies on the AML code to process all such tasks, the present invention detects tasks that are more suitably processed by SMI handler code based on the particular tasks detected in the tasks registers. In an ACPI environment, such transfers are within the management control of the operating system, yet the AML code limitations affect efficient execution of certain complex tasks. - Complex tasks suitable for the SMI handler include, but are not limited to, handling and transferring large amounts of data that has to be gathered dynamically during runtime, saving and restoring devices coming out of suspend state, determining device standards, accessing features not accessible to the ASL code and so forth. Complex tasks requiring transfer or search of large bodies of data are particularly problematic, since the AML access to memory, I/O and PCI configuration space is either static or else the capabilities provided for dynamic values are so limited as to be largely useless. This makes it difficult for code developers to develop optimal code that can execute fast and hence positively affect performance. In a typical implementation, ROM images need to be copied from a flash component to memory area. A SMI is generated by the control code and a SMI handler correspondingly copies the flash component to the memory area. After the task is completed, control is transferred back to ASL code. One skilled in the art will recognize that embodiments of the present invention can be configured to allow the control method to generate an SMI interrupt and consequently enable SMI handler code to handle any kind of tasks, including those which may be handled readily by the ASL code as well.
- Referring to FIG. 1, ACPI table118 is a collection of registers. The status registers are software readable by ACPI
driver 110. These are also hardware readable in the context that the hardware can read the status bit in order to determine whether to generate a SMI. The base address of the task register and the lengths of the task blocks are all defined in ACPI table 118. In accordance with the ACPI specification, between zero and 255 task inputs can be implemented. The task status register, containing the task status bits, thus allows 255 tasks (i.e., status register values). - Upon receiving a task that is identified as handled using ASL capabilities, a SCI arbiter accesses
ACPI driver 110, which either passes control to an ACPI-aware driver, or uses a manufacturer-supplied control method ordevice driver 112, to handle the task.ACPI driver 110 determines which status bit, among the status bits in the task register, is asserted. As indicated above, each status bit, and its corresponding enable bit, is hard-wired and dedicated to receive a particular task. The selection of a control method ordevice driver 112 is determined by which bit received the signal indicating the task. - As shown in FIG. 2, when a complex task is encountered, the control method invokes a SMI from within ACPI code to handle operations in an optimal way (step206). The chipset has a capability to generate an SMI based on accesses to predefined I/O address locations. The control method accesses the I/O address location that is programmed to trigger an SMI by using the chipset capability. An SMI is generated in the path of ASL code execution to enable usage of flexible native CPU instruction set within the SMI handler. A software SMI generation I/O register access is used to force an SMI occurrence within the ASL code execution path. In particular, an operation region is defined for the SMI I/O address that is being accessed. Once an operation region is defined for an I/O address, this newly defined entity can be accessed from within any of the control methods to generate an SMI.
- The control method performs whatever action is appropriate for the task it handles. For example, if the task requires complex data handling and transfer, the control method acknowledges the task as one handled by a SMI handler. Thus, when
ACPI driver 110 detects the assertion of an enable bit of the task register, it calls theappropriate driver 112 according to the particular task register pin asserted and according to ACPI table 118. If the task register pin and table 118 indicate that the task should be handled by SMM code, an SMI is generated within the ACPI code and the SMI handler handles the task. The operating system sets the SMI enable bit for the device in the SMI generation I/O register when a complex task is detected. - The SMI handler then processes the complex task (step208). Embodiments of the present invention thus identify and redirect complicated tasks in the ACPI ASL code to the SMM. In this manner, some or all of the complicated tasks handled by the ACPI ASL code are instead handled by the SMM. In particular, once an SMI is invoked, the processor stops and processes the SMI. An SMI handler is given control for the various processors at different address locations. Each processor SMI handler starts executing its code once it has been invoked. The SMI handler code gets various tasks that have to be executed through the I/O address contents. In this regard, the SMI handler takes the appropriate code path to handle complicated tasks for which it has been invoked. The data can be easily gathered from within the SMI handler code instead of writing complex ACPI ASL code. By allowing the SMI handler to handle complicated tasks, the difficulties associated with using ACPI ASL code is minimized. The same data transfer can now occur faster during runtime OS execution by using the processor's powerful instruction set capability and in some cases having multiple processors being available for data processing allows for good delegation of tasks between the processing power that is available on the platform.
- SMM is invoked by generating a SMI signal to processor. Processor, in response, asserts the SMI control signal that accesses a SMRAM region. The current processor state (i.e. context) is stored in extended SMRAM after assertion of the SMI signal and processor then jumps to a location in SMRAM to execute the extended SMI handler code for the complex task.
- Upon completion of the complex task, the SMI handler executes a resume (RSM) instruction that restores processor's context from SMRAM, de-asserts the SMI signal, and then returns control to the control method under ACPI ASL code (
steps - FIG. 3 illustrates a flow diagram of an
embodiment 300 of a process for enabling a control method executed by the operating system under ACPI control to handle tasks, including complex tasks. The processor along with a memory includes a software routine that, during runtime, detects the assertion of a signal on the task register bit connected to the device. The assertion of the signal on the task register bit and then determination that the task comprises a complex task suitable for execution by the SMI handler, calls the software routine. The software routine obviates the need for the ACPI ASL code to execute complex instructions more suitable for the SMI handler to execute. Enable bits are read and written by software, and indicate to the system whether a task occurrence from a particular device is to be executed by the SMI handler instead. - Under OS runtime execution (step302),
ACPI driver 110 queues control methods to handle each task (step 304). - When a complex task is encountered (step306), the control method invokes a SMI from within ACPI code to handle operations in an optimal way (step 308). The ACPI control method accesses the I/O address location that triggers an SMI signal to the processor by using the chipset capability. A SMI is generated in the path of ASL code execution to enable usage of flexible native CPU instruction set within the SMI handler.
- The SMI handler then processes the complex task (step310). Embodiments of the present invention thus identify and redirect complicated tasks in the ACPI ASL code to the SMM.
- Upon completion of the complex task, the SMI handler executes a resume (RSM) instruction that restores processor's context from SMRAM, de-asserts the SMI signal, and then returns control to the control method under ACPI ASL code (
steps 312, 314). - If a complex task is not detected (step306), then processing is continued under ASL control (step 314) and a SMI is not generated.
- In accordance with another embodiment of the invention, a task occurrence from a hardware device sets a status bit, corresponding to the device status bits are set in hardware, and are read both by hardware in order to cause the SCI task occurrence. The enable bit corresponding to that status bit (and to the device) may be set as well.
- Having now described the invention in accordance with the requirements of the patent statutes, those skilled in the art will understand how to make changes and modifications to the present invention to meet their specific requirements or conditions. Such changes and modifications may be made without departing from the scope and spirit of the invention as set forth in the following claims.
Claims (18)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/039,054 US7325146B2 (en) | 2001-12-31 | 2001-12-31 | Method and apparatus for generating SMI from ACPI ASL control code to execute complex tasks |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/039,054 US7325146B2 (en) | 2001-12-31 | 2001-12-31 | Method and apparatus for generating SMI from ACPI ASL control code to execute complex tasks |
Publications (2)
Publication Number | Publication Date |
---|---|
US20030135534A1 true US20030135534A1 (en) | 2003-07-17 |
US7325146B2 US7325146B2 (en) | 2008-01-29 |
Family
ID=21903408
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US10/039,054 Expired - Fee Related US7325146B2 (en) | 2001-12-31 | 2001-12-31 | Method and apparatus for generating SMI from ACPI ASL control code to execute complex tasks |
Country Status (1)
Country | Link |
---|---|
US (1) | US7325146B2 (en) |
Cited By (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030236935A1 (en) * | 2002-06-21 | 2003-12-25 | Takeshi Amemiya | System for processing programmable buttons using system control interrupts |
US20040236934A1 (en) * | 2003-05-21 | 2004-11-25 | Zimmer Vincent J. | Pre-boot interpreted namespace parsing for flexible heterogeneous configuration and code consolidation |
US20050138256A1 (en) * | 2003-12-23 | 2005-06-23 | Bolay Frederick H. | Method and apparatus for processing hot key input using operating system visible interrupt handling |
US20060143598A1 (en) * | 2004-12-29 | 2006-06-29 | Zimmer Vincent J | Method and apparatus for transforming program representations |
US20060174231A1 (en) * | 2005-01-31 | 2006-08-03 | Dong Wei | Method and an apparatus for using code written in a language that is not native to the computer system to invoke a procedure written in a programming language that is native to the computer system |
US20070005860A1 (en) * | 2005-06-29 | 2007-01-04 | Inventec Corporation | Interrupt control system and method |
US20090320128A1 (en) * | 2008-06-04 | 2009-12-24 | Dell Products L.P. | System management interrupt (smi) security |
US20130179712A1 (en) * | 2012-01-11 | 2013-07-11 | Giga-Byte Technology Co., Ltd. | All-in-one Computer and Power Management Method thereof |
US20140207988A1 (en) * | 2013-01-24 | 2014-07-24 | Allen C. Wynn | System and method for secure smi memory services |
TWI456503B (en) * | 2012-05-23 | 2014-10-11 | Insyde Software Corp | Method, recording medium and computer program product for executing basic input/output system tool program without system management interruption mechanism |
US20150019855A1 (en) * | 2013-07-11 | 2015-01-15 | Insyde Software Corp. | System Platform Supporting Infrared Receiver/Transmitter and Operation Method Thereof |
US20160011646A1 (en) * | 2014-07-14 | 2016-01-14 | American Megatrends, Inc. | Service processor (sp) intiateed data transaction with bios utilizing power off commands |
Families Citing this family (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20070226795A1 (en) * | 2006-02-09 | 2007-09-27 | Texas Instruments Incorporated | Virtual cores and hardware-supported hypervisor integrated circuits, systems, methods and processes of manufacture |
EP2075696A3 (en) * | 2007-05-10 | 2010-01-27 | Texas Instruments Incorporated | Interrupt- related circuits, systems and processes |
US7730248B2 (en) * | 2007-12-13 | 2010-06-01 | Texas Instruments Incorporated | Interrupt morphing and configuration, circuits, systems and processes |
Citations (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5530891A (en) * | 1994-05-31 | 1996-06-25 | Advanced Micro Devices | System management interrupt mechanism within a symmetrical multiprocessing system |
US6122748A (en) * | 1998-03-31 | 2000-09-19 | Compaq Computer Corporation | Control of computer system wake/sleep transitions |
US6185677B1 (en) * | 1998-09-30 | 2001-02-06 | Phoenix Technologies Ltd. | Automatic generation of ACPI source language for peripheral resource configuration |
US6212592B1 (en) * | 1998-09-17 | 2001-04-03 | Micron Technology, Inc. | Computer system for processing system management interrupt requests |
US6219742B1 (en) * | 1998-04-29 | 2001-04-17 | Compaq Computer Corporation | Method and apparatus for artificially generating general purpose events in an ACPI environment |
US6282601B1 (en) * | 1999-03-31 | 2001-08-28 | International Business Machines Corporation | Multiprocessor data processing system and method of interrupt handling that facilitate identification of a processor requesting a system management interrupt |
US6321289B1 (en) * | 1999-04-08 | 2001-11-20 | Micron Technology, Inc. | Apparatus for automatically notifying operating system level applications of the occurrence of system management events |
US6775728B2 (en) * | 2001-11-15 | 2004-08-10 | Intel Corporation | Method and system for concurrent handler execution in an SMI and PMI-based dispatch-execution framework |
US6792491B2 (en) * | 2001-12-21 | 2004-09-14 | Intel Corporation | Invoking ACPI source language code from interrupt handler |
US6895517B2 (en) * | 2001-08-22 | 2005-05-17 | Via Technologies, Inc. | Method of synchronizing operation frequencies of CPU and system RAM in power management process |
-
2001
- 2001-12-31 US US10/039,054 patent/US7325146B2/en not_active Expired - Fee Related
Patent Citations (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5530891A (en) * | 1994-05-31 | 1996-06-25 | Advanced Micro Devices | System management interrupt mechanism within a symmetrical multiprocessing system |
US6122748A (en) * | 1998-03-31 | 2000-09-19 | Compaq Computer Corporation | Control of computer system wake/sleep transitions |
US6219742B1 (en) * | 1998-04-29 | 2001-04-17 | Compaq Computer Corporation | Method and apparatus for artificially generating general purpose events in an ACPI environment |
US6212592B1 (en) * | 1998-09-17 | 2001-04-03 | Micron Technology, Inc. | Computer system for processing system management interrupt requests |
US6185677B1 (en) * | 1998-09-30 | 2001-02-06 | Phoenix Technologies Ltd. | Automatic generation of ACPI source language for peripheral resource configuration |
US6282601B1 (en) * | 1999-03-31 | 2001-08-28 | International Business Machines Corporation | Multiprocessor data processing system and method of interrupt handling that facilitate identification of a processor requesting a system management interrupt |
US6321289B1 (en) * | 1999-04-08 | 2001-11-20 | Micron Technology, Inc. | Apparatus for automatically notifying operating system level applications of the occurrence of system management events |
US6895517B2 (en) * | 2001-08-22 | 2005-05-17 | Via Technologies, Inc. | Method of synchronizing operation frequencies of CPU and system RAM in power management process |
US6775728B2 (en) * | 2001-11-15 | 2004-08-10 | Intel Corporation | Method and system for concurrent handler execution in an SMI and PMI-based dispatch-execution framework |
US6792491B2 (en) * | 2001-12-21 | 2004-09-14 | Intel Corporation | Invoking ACPI source language code from interrupt handler |
Cited By (18)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030236935A1 (en) * | 2002-06-21 | 2003-12-25 | Takeshi Amemiya | System for processing programmable buttons using system control interrupts |
US7139850B2 (en) * | 2002-06-21 | 2006-11-21 | Fujitsu Limited | System for processing programmable buttons using system interrupts |
US20040236934A1 (en) * | 2003-05-21 | 2004-11-25 | Zimmer Vincent J. | Pre-boot interpreted namespace parsing for flexible heterogeneous configuration and code consolidation |
US7107441B2 (en) * | 2003-05-21 | 2006-09-12 | Intel Corporation | Pre-boot interpreted namespace parsing for flexible heterogeneous configuration and code consolidation |
US20050138256A1 (en) * | 2003-12-23 | 2005-06-23 | Bolay Frederick H. | Method and apparatus for processing hot key input using operating system visible interrupt handling |
US20060143598A1 (en) * | 2004-12-29 | 2006-06-29 | Zimmer Vincent J | Method and apparatus for transforming program representations |
US20060174231A1 (en) * | 2005-01-31 | 2006-08-03 | Dong Wei | Method and an apparatus for using code written in a language that is not native to the computer system to invoke a procedure written in a programming language that is native to the computer system |
US20070005860A1 (en) * | 2005-06-29 | 2007-01-04 | Inventec Corporation | Interrupt control system and method |
US20090320128A1 (en) * | 2008-06-04 | 2009-12-24 | Dell Products L.P. | System management interrupt (smi) security |
US20130179712A1 (en) * | 2012-01-11 | 2013-07-11 | Giga-Byte Technology Co., Ltd. | All-in-one Computer and Power Management Method thereof |
TWI456503B (en) * | 2012-05-23 | 2014-10-11 | Insyde Software Corp | Method, recording medium and computer program product for executing basic input/output system tool program without system management interruption mechanism |
US20140207988A1 (en) * | 2013-01-24 | 2014-07-24 | Allen C. Wynn | System and method for secure smi memory services |
US9047263B2 (en) * | 2013-01-24 | 2015-06-02 | Dell Products L.P. | System and method for secure SMI memory services |
US9697354B2 (en) | 2013-01-24 | 2017-07-04 | Dell Products L.P. | System and method for secure SMI memory services |
US20150019855A1 (en) * | 2013-07-11 | 2015-01-15 | Insyde Software Corp. | System Platform Supporting Infrared Receiver/Transmitter and Operation Method Thereof |
US9858087B2 (en) * | 2013-07-11 | 2018-01-02 | Insyde Software Corp. | System platform supporting infrared receiver/transmitter and operation method thereof |
US20160011646A1 (en) * | 2014-07-14 | 2016-01-14 | American Megatrends, Inc. | Service processor (sp) intiateed data transaction with bios utilizing power off commands |
US9529410B2 (en) * | 2014-07-14 | 2016-12-27 | American Megatrends, Inc. | Service processor (SP) initiated data transaction with BIOS utilizing power off commands |
Also Published As
Publication number | Publication date |
---|---|
US7325146B2 (en) | 2008-01-29 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7325146B2 (en) | Method and apparatus for generating SMI from ACPI ASL control code to execute complex tasks | |
US6480952B2 (en) | Emulation coprocessor | |
US6219742B1 (en) | Method and apparatus for artificially generating general purpose events in an ACPI environment | |
US6272618B1 (en) | System and method for handling interrupts in a multi-processor computer | |
US5706514A (en) | Distributed execution of mode mismatched commands in multiprocessor computer systems | |
US5796984A (en) | Operating system independent apparatus and method for eliminating peripheral device functions | |
US7917740B1 (en) | Virtualization assist for legacy x86 floating point exception handling | |
US6185677B1 (en) | Automatic generation of ACPI source language for peripheral resource configuration | |
JP3314378B2 (en) | System and method for managing memory allocation for executable programs | |
US5896534A (en) | Operating system independent apparatus and method for supporting input/output devices unsupported by executing programs | |
US8001359B2 (en) | Mapping an N-bit application ported from an M-bit application to an N-bit architecture | |
US8255594B2 (en) | Handling legacy BIOS services for mass storage devices using systems management interrupts with or without waiting for data transferred to mass storage devices | |
US7454547B1 (en) | Data exchange between a runtime environment and a computer firmware in a multi-processor computing system | |
US5978903A (en) | Apparatus and method for automatically accessing a dynamic RAM for system management interrupt handling | |
US20040268113A1 (en) | Virtual out-of-band management controller | |
JPH06187133A (en) | Loading system of operating system, detection system of device connection and decision method of loader of operating system | |
US20010018721A1 (en) | Upgrade card for a computer system | |
US6694401B2 (en) | Method and apparatus for executing real-mode interrupts from within extended SMRAM handler | |
US6775734B2 (en) | Memory access using system management interrupt and associated computer system | |
JP2004258840A (en) | Computer system with virtualized I / O devices | |
US7418714B2 (en) | Employing three parameter buffer access in connection with SMBus notifications | |
US7178014B2 (en) | Method and apparatus for using a memory region to pass parameters between a run time environment and SMM handler | |
US6907521B2 (en) | Enabling video BIOS and display drivers to leverage system BIOS platform abstract | |
US7558724B2 (en) | Operation region describing a virtual device | |
EP0575171B1 (en) | Enhanced system management method and apparatus |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: INTEL CORPORATION, CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:NALAWADI, RAJEEV K.;BOLAY, FRED H.;REEL/FRAME:012781/0067;SIGNING DATES FROM 20020319 TO 20020321 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
FPAY | Fee payment |
Year of fee payment: 4 |
|
FPAY | Fee payment |
Year of fee payment: 8 |
|
FEPP | Fee payment procedure |
Free format text: MAINTENANCE FEE REMINDER MAILED (ORIGINAL EVENT CODE: REM.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
LAPS | Lapse for failure to pay maintenance fees |
Free format text: PATENT EXPIRED FOR FAILURE TO PAY MAINTENANCE FEES (ORIGINAL EVENT CODE: EXP.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
STCH | Information on status: patent discontinuation |
Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362 |
|
FP | Expired due to failure to pay maintenance fee |
Effective date: 20200129 |