11 June 2002. Summary of changes for this release.
1) ACPI CA Core Subsystem Version 20020611:
Fixed a reported problem where constants such as Zero and One appearing within _PRT packages were not handled correctly within the resource manager code. Originally reported against the ASL compiler because the code generator now optimizes integers to their minimal AML representation (i.e. AML constants if possible.) The _PRT code now handles all AML constant opcodes correctly (Zero, One, Ones, Revision).
Fixed a problem with the Concatenate operator in the AML interpreter where a buffer result object was incorrectly marked as not fully evaluated, causing a run-time error of AE_AML_INTERNAL.
All package sub-objects are now fully resolved before they are returned from the external ACPI interfaces. This means that name strings are resolved to object handles, and constant operators (Zero, One, Ones, Revision) are resolved to Integers.
Implemented immediate resolution of the AML Constant opcodes (Zero, One, Ones, Revision) to Integer objects upon detection within the AML stream. This has simplified and reduced the generated code size of the subsystem by eliminating about 10 switch statements for these constants (which previously were contained in Reference objects.) The complicating issues are that the Zero opcode is used as a "placeholder" for unspecified optional target operands and stores to constants are defined to be no-ops.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Previous Release
Non-Debug Version: 69.3K Code, 7.4K Data, 76.7K Total
Debug Version: 143.8K Code, 58.8K Data, 202.6K Total
Current Release:
Non-Debug Version: 68.7K Code, 7.4K Data, 76.1K Total
Debug Version: 142.9K Code, 58.7K Data, 201.6K Total
2) Linux
Added preliminary support for obtaining _TRA data for PCI root bridges (Bjorn Helgaas).
3) iASL Compiler Version X2046:
Fixed a problem where the "_DDN" reserved name was defined to be a control method with one argument. There are no arguments, and _DDN does not have to be a control method.
Fixed a problem with the Linux version of the compiler where the source lines printed with error messages were the wrong lines. This turned out to be the "LF versus CR/LF" difference between Windows and Unix. This appears to be the longstanding issue concerning listing output and error messages.
Fixed a problem with the Linux version of compiler where opcode names within error messages were wrong. This was caused by a slight difference in the output of the Flex tool on Linux versus Windows.
Fixed a problem with the Linux compiler where the hex output files contained some garbage data caused by an internal buffer overrun.
Implemented a workaround to an BIOS bug discovered on the HP OmniBook where the FADT revision number and the table size are inconsistent (ACPI 2.0 revision vs. ACPI 1.0 table size). The new behavior is to fallback to using only the ACPI 1.0 fields of the FADT if the table is too small to be a ACPI 2.0 table as claimed by the revision number. Although this is a BIOS bug, this is a case where the workaround is simple enough and with no side effects, so it seemed prudent to add it. A warning message is issued, however.
Implemented minimum size checks for the fixed-length ACPI tables -- the FADT and FACS, as well as consistency checks between the revision number and the table size.
Fixed a reported problem in the table override support where the new table pointer was incorrectly treated as a physical address instead of a logical address.
Eliminated the use of the AE_AML_ERROR exception and replaced it with more descriptive codes.
Fixed a problem where an exception would occur if an ASL Field was defined with no named Field Units underneath it (used by some index fields).
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Previous Release
Non-Debug Version: 68.8K Code, 7.1K Data, 75.9K Total
Debug Version: 142.9K Code, 58.4K Data, 201.3K Total
Current Release:
Non-Debug Version: 69.3K Code, 7.4K Data, 76.7K Total
Debug Version: 143.8K Code, 58.8K Data, 202.6K Total
2) Linux
Much work done on ACPI init (MADT and PCI IRQ routing support). (Paul D. and Dominik Brodowski)
Fix PCI IRQ-related panic on boot (Sam Revitch)
Set BM_ARB_DIS when entering a sleep state (Ducrot Bruno)
Moved arch-specific code out of include/platform/aclinux.h
3) iASL Compiler Version X2044:
Implemented error checking for the string used in the EISAID macro (Usually used in the definition of the _HID object.) The code now strictly enforces the PnP format - exactly 7 characters, 3 uppercase letters and 4 hex digits.
If a raw string is used in the definition of the _HID object (instead of the EISAID macro), the string must contain all alphanumeric characters (e.g., "*PNP0011" is not allowed because of the asterisk.)
Implemented checking for invalid use of ACPI reserved names for most of the name creation operators (Name, Device, Event, Mutex, OperationRegion, PowerResource, Processor, and ThermalZone.) Previously, this check was only performed for control methods.
Implemented an additional check on the Name operator to emit an error if a reserved name that must be implemented in ASL as a control method is used. We know that a reserved name must be a method if it is defined with input arguments.
The warning emitted when a namespace object reference is not found during the cross reference phase has been changed into an error. The "External" directive should be used for names defined in other modules.
4) Tools and Utilities
The 16-bit tools (adump16 and aexec16) have been regenerated and tested.
Fixed a problem with the output of both acpidump and adump16 where the indentation of closing parentheses and brackets was not aligned properly with the parent block.
Added support a new OSL interface that allows the host operating system software to override the DSDT found in the firmware - AcpiOsTableOverride. With this interface, the OSL can examine the version of the firmware DSDT and replace it with a different one if desired.
Added new external interfaces for accessing ACPI registers from device drivers and other system software - AcpiGetRegister and AcpiSetRegister. This was simply an externalization of the existing AcpiHwBitRegister interfaces.
Fixed a regression introduced in the previous build where the ASL/AML CreateField operator always returned an error, "destination must be a NS Node".
Extended the maximum time (before failure) to successfully enable ACPI mode to 3 seconds.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Previous Release
Non-Debug Version: 68.5K Code, 7.0K Data, 75.5K Total
Debug Version: 142.4K Code, 58.3K Data, 200.7K Total
Current Release:
Non-Debug Version: 68.8K Code, 7.1K Data, 75.9K Total
Debug Version: 142.9K Code, 58.4K Data, 201.3K Total
2) Linux
Enhanced ACPI init code for SMP. We are now fully MPS and $PIR-free. While 3 out of 4 of our in-house systems work fine, the last one still hangs when testing the LAPIC timer.
Renamed many files in 2.5 kernel release to omit "acpi_" from the name.
Added warning on boot for Presario 711FR.
Sleep improvements (Pavel Machek)
ACPI can now be built without CONFIG_PCI enabled.
IA64: Fixed memory map functions (JI Lee)
3) iASL Compiler Version X2043:
Added support to allow the compiler to be integrated into the MS VC++ development environment for one-button compilation of single files or entire projects -- with error-to-source-line mapping.
Implemented support for compile-time constant folding for the Type3, Type4, and Type5 opcodes first defined in the ACPI 2.0 specification. This allows the ASL writer to use expressions instead of Integer/Buffer/String constants in terms that must evaluate to constants at compile time and will also simplify the emitted AML in any such sub-expressions that can be folded (evaluated at compile-time.) This increases the size of the compiler significantly because a portion of the ACPI CA AML interpreter is included within the compiler in order to pre-evaluate constant expressions.
Fixed a problem with the "Unicode" ASL macro that caused the compiler to fault. (This macro is used in conjunction with the _STR reserved name.)
Implemented an AML opcode optimization to use the Zero, One, and Ones opcodes where possible to further reduce the size of integer constants and thus reduce the overall size of the generated AML code.
Implemented error checking for new reserved terms for ACPI version 2.0A.
Implemented the -qr option to display the current list of ACPI reserved names known to the compiler.
Implemented the -qc option to display the current list of ASL operators that are allowed within constant expressions and can therefore be folded at compile time if the operands are constants.
4) Documentation
Updated the Programmer's Reference for new interfaces, data types, and memory allocation model options.
Updated the iASL Compiler User Reference to apply new format and add information about new features and options.
19 April 2002. Summary of changes for this release.
1) ACPI CA Core Subsystem Version 20020419:
The source code base for the Core Subsystem has been completely cleaned with PC-lint (FlexLint) for both 32-bit and 64-bit versions. The Lint option files used are included in the /acpi/generate/lint directory.
Implemented enhanced status/error checking across the entire Hardware manager subsystem. Any hardware errors (reported from the OSL) are now bubbled up and will abort a running control method.
Fixed a problem where the per-ACPI-table integer width (32 or 64) was stored only with control method nodes, causing a fault when non-control method code was executed during table loading. The solution implemented uses a global variable to indicate table width across the entire ACPI subsystem. Therefore, ACPI CA does not support mixed integer widths across different ACPI tables (DSDT, SSDT).
Fixed a problem where NULL extended fields (X fields) in an ACPI 2.0 ACPI FADT caused the table load to fail. Although the existing ACPI specification is a bit fuzzy on this topic, the new behavior is to fall back on a ACPI 1.0 field if the corresponding ACPI 2.0 X field is zero (even though the table revision indicates a full ACPI 2.0 table.) The ACPI specification will be updated to clarify this issue.
Fixed a problem with the SystemMemory operation region handler where memory was always accessed byte-wise even if the AML-specified access width was larger than a byte. This caused problems on systems with memory-mapped I/O. Memory is now accessed with the width specified. On systems that do not support non-aligned transfers, a check is made to guarantee proper address alignment before proceeding in order to avoid an AML-caused alignment fault within the kernel.
Fixed a problem with the ExtendedIrq resource where only one byte of the 4-byte Irq field was extracted.
Fixed the AcpiExDigitsNeeded() procedure to support _UID. This function was out of date and required a rewrite.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Previous Release
Non-Debug Version: 66.6K Code, 6.5K Data, 73.1K Total
Debug Version: 139.8K Code, 57.4K Data, 197.2K Total
Current Release:
Non-Debug Version: 68.5K Code, 7.0K Data, 75.5K Total
Debug Version: 142.4K Code, 58.3K Data, 200.7K Total
2) Linux
PCI IRQ routing fixes (Dominik Brodowski)
3) iASL Compiler Version X2042:
Implemented an additional compile-time error check for a field unit whose size + minimum access width would cause a run-time access beyond the end-of-region. Previously, only the field size itself was checked.
The Core subsystem and iASL compiler now share a common parse object in preparation for compile-time evaluation of the type 3/4/5 ASL operators.
Implemented support for late evaluation of TermArg operands to Buffer and Package objects. This allows complex expressions to be used in the declarations of these object types.
Fixed an ACPI 1.0 compatibility issue when reading Fields. In ACPI 1.0, if the field was larger than 32 bits, it was returned as a buffer <20> otherwise it was returned as an integer. In ACPI 2.0, the field is returned as a buffer only if the field is larger than 64 bits. The TableRevision is now considered when making this conversion to avoid incompatibility with existing ASL code.
Implemented logical addressing for AcpiOsGetRootPointer. This allows an RSDP with either a logical or physical address. With this support, the host OS can now override all ACPI tables with one logical RSDP. Includes implementation of <20>typed<65> pointer support to allow a common data type for both physical and logical pointers internally. This required a change to the AcpiOsGetRootPointer interface.
Implemented the use of ACPI 2.0 Generic Address Structures for all GPE, Fixed Event, and PM Timer I/O. This allows the use of memory mapped I/O for these ACPI features.
Initialization now ignores not only non-required tables (All tables other than the FADT, FACS, DSDT, and SSDTs), but also does not validate the table headers of unrecognized tables.
Fixed a problem where a notify handler could only be installed/removed on an object of type Device. All "notify" objects are now supported -- Devices, Processor, Power, and Thermal.
Removed most verbosity from the ACPI_DB_INFO debug level. Only critical information is returned when this debug level is enabled.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Previous Release
Non-Debug Version: 65.4K Code, 6.2K Data, 71.6K Total
Debug Version: 138.0K Code, 56.6K Data, 194.6K Total
Current Release:
Non-Debug Version: 66.6K Code, 6.5K Data, 73.1K Total
Debug Version: 139.8K Code, 57.4K Data, 197.2K Total
2) Linux:
The processor driver (acpi_processor.c) now fully supports ACPI 2.0-based processor performance control (e.g. Intel(R) SpeedStep(TM) technology) Note that older laptops that only have the Intel "applet" interface are not supported through this. The 'limit' and 'performance' interface (/proc) are fully functional. [Note that basic policy for controlling performance state transitions will be included in the next version of ospmd.] The idle handler was modified to more aggressively use C2, and PIIX4 errata handling underwent a complete overhaul (big thanks to Dominik Brodowski).
Added support for ACPI-PCI device binding (acpi_pci_root.c). _ADR-based devices in the ACPI namespace are now dynamically bound (associated) with their PCI counterparts (e.g. PCI1->01:00.0). This allows, among other things, ACPI to resolve bus numbers for subordinate PCI bridges.
Enhanced PCI IRQ routing to get the proper bus number for _PRT entries defined underneath PCI bridges.
Added IBM 600E to bad bios list due to invalid _ADR value for PIIX4 PCI-ISA bridge, resulting in improper PCI IRQ routing.
In the process of adding full MADT support (e.g. IOAPIC) for IA32 (acpi.c, mpparse.c) -- stay tuned.
Added back visual differentiation between fixed-feature and control-method buttons in dmesg. Buttons are also subtyped (e.g. button/power/PWRF) to simplify button identification.
We no longer use -Wno-unused when compiling debug. Please ignore any "_THIS_MODULE defined but not used" messages.
Can now shut down the system using "magic sysrq" key.
3) iASL Compiler version 2041:
Fixed a problem where conversion errors for hex/octal/decimal constants were not reported.
Implemented a fix for the General Register template Address field. This field was 8 bits when it should be 64.
Fixed a problem where errors/warnings were no longer being emitted within the listing output file.
Implemented the ACPI 2.0A restriction on ACPI Table Signatures to exactly 4 characters, alphanumeric only.
Fixed a problem with AML Fields where the use of the "AccessAny" keyword could cause an interpreter error due to attempting to read or write beyond the end of the parent Operation Region.
Fixed a problem in the SystemMemory Operation Region handler where an attempt was made to map memory beyond the end of the region. This was the root cause of the "AE_ERROR" and "AE_NO_MEMORY" errors on some Linux systems.
Fixed a problem where the interpreter/namespace "search to root" algorithm was not functioning for some object types. Relaxed the internal restriction on the search to allow upsearches for all external object types as well as most internal types.
2) Linux:
We now use safe_halt() macro versus individual calls to sti | hlt.
Writing to the processor limit interface should now work. "echo 1" will increase the limit, 2 will decrease, and 0 will reset to the default.
Fixed a problem where the GPE bit masks were not initialized properly, causing erratic GPE behavior.
Implemented limited support for multiple calling conventions. The code can be generated with either the VPL (variable parameter list, or "C") convention, or the FPL (fixed parameter list, or "Pascal") convention. The core subsystem is about 3.4% smaller when generated with FPL.
2) Linux
Re-add some /proc/acpi/event functionality that was lost during the rewrite
Resolved issue with /proc events for fixed-feature buttons showing up as the system device.
Fixed checks on C2/C3 latencies to be inclusive of maximum values.
Replaced AE_ERRORs in acpi_osl.c with more specific error codes.
Changed ACPI PRT option from "pci=noacpi-routing" to "pci=noacpi"
Fixed limit interface & usage to fix bugs with passive cooling hysterisis.
Implemented support in AcpiLoadTable to allow loading of FACS and FADT tables.
Suport for the now-obsolete interim 0.71 64-bit ACPI tables has been removed. All 64-bit platforms should be migrated to the ACPI 2.0 tables. The actbl71.h header has been removed from the source tree.
All C macros defined within the subsystem have been prefixed with "ACPI_" to avoid collision with other system include files.
Removed the return value for the two AcpiOsPrint interfaces, since it is never used and causes lint warnings for ignoring the return value.
Added error checking to all internal mutex acquire and release calls. Although a failure from one of these interfaces is probably a fatal system error, these checks will cause the immediate abort of the currently executing method or interface.
Fixed a problem where the AcpiSetCurrentResources interface could fault. This was a side effect of the deployment of the new memory allocation model.
Fixed a couple of problems with the Global Lock support introduced in the last major build. The "common" (1.0/2.0) internal FACS was being overwritten with the FACS signature and clobbering the Global Lock pointer. Also, the actual firmware FACS was being unmapped after construction of the "common" FACS, preventing access to the actual Global Lock field within it. The "common" internal FACS is no longer installed as an actual ACPI table; it is used simply as a global.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Implemented the new compiler restriction on ASL String hex/octal escapes to non-null, ASCII values. An error results if an invalid value is used. (This will require an ACPI 2.0 specification change.)
AML object labels that are output to the optional C and ASM source are now prefixed with both the ACPI table signature and table ID to help guarantee uniqueness within a large BIOS project.
ACPI 2.0 support is complete in the entire Core Subsystem and the ASL compiler. All new ACPI 2.0 operators are implemented and all other changes for ACPI 2.0 support are complete. With simultaneous code and data optimizations throughout the subsystem, ACPI 2.0 support has been implemented with almost no additional cost in terms of code and data size.
Implemented a new mechanism for allocation of return buffers. If the buffer length is set to ACPI_ALLOCATE_BUFFER, the buffer will be allocated on behalf of the caller. Consolidated all return buffer validation and allocation to a common procedure. Return buffers will be allocated via the primary OSL allocation interface since it appears that a separate pool is not needed by most users. If a separate pool is required for these buffers, the caller can still use the original mechanism and pre-allocate the buffer(s).
Obsoleted the AcpiOsCallocate OSL interface. This interface was used only a handful of times and didn't have enough critical mass for a separate interface. Replaced with a common calloc procedure in the core.
Fixed a reported problem with the GPE number mapping mechanism that allows GPE1 numbers to be non-contiguous with GPE0. Reorganized the GPE information and shrunk a large array that was originally large enough to hold info for all possible GPEs (256) to simply large enough to hold all GPEs up to the largest GPE number on the machine.
Implemented Field support in the ASL Load operator. This allows a table to be loaded from a named field, in addition to loading a table directly from an Operation Region.
Implemented timeout and handle support in the external Global Lock interfaces.
Fixed a problem in the AcpiDump utility where pathnames were no longer being generated correctly during the dump of named objects.
Modified the AML debugger to give a full display of if/while predicates instead of just one AML opcode at a time. (The predicate can have several nested ASL statements.) The old method was confusing during single stepping.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Implemented several new output features to simplify integration of AML code into firmware: 1) Output the AML in C source code with labels for each named ASL object. The original ASL source code is interleaved as C comments. 2) Output the AML in ASM source code with labels and interleaved ASL source. 3) Output the AML in raw hex table form, in either C or ASM.
Implemented support for optional string parameters to the LoadTable operator.
Completed support for embedded escape sequences within string literals. The compiler now supports all single character escapes as well as the Octal and Hex escapes. Note: the insertion of a null byte into a string literal (via the hex/octal escape) causes the string to be immediately terminated. A warning is issued.
Fixed a problem where incorrect AML was generated for the case where an ASL namepath consists of a single parent prefix (
Completed implementation of the ACPI 2.0 "Continue", "ConcatenateResTemplate", "DataTableRegion", and "LoadTable" operators. All new ACPI 2.0 operators are now implemented in both the ASL compiler and the AML interpreter. The only remaining ACPI 2.0 task is support for the String data type in the DerefOf operator. Fixed a problem with AcquireMutex where the status code was lost if the caller had to actually wait for the mutex.
Completed implementation of the external Global Lock interfaces -- AcpiAcquireGlobalLock and AcpiReleaseGlobalLock. The Timeout and Handler parameters were added.
Completed another pass at removing warnings and issues when compiling with 64-bit compilers. The code now compiles cleanly with the Intel 64-bit C/C++ compiler. Most notably, the pointer add and subtract (diff) macros have changed considerably.
Created and deployed a new ACPI_SIZE type that is 64-bits wide on 64-bit platforms, 32-bits on all others. This type is used wherever memory allocation and/or the C sizeof() operator is used, and affects the OSL memory allocation interfaces AcpiOsAllocate and AcpiOsCallocate.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
The ACPI 2.0 CopyObject operator is fully implemented. This operator creates a new copy of an object (and is also used to bypass the "implicit conversion" mechanism of the Store operator.)
The ACPI 2.0 semantics for the SizeOf operator are fully implemented. The change is that performing a SizeOf on a reference object causes an automatic dereference of the object to tha actual value before the size is evaluated. This behavior was undefined in ACPI 1.0.
Fixed a problem where ASL Constants (Zero, One, Ones, Revision) appearing in Package objects were not properly converted to integers when the internal Package was converted to an external object (via the AcpiEvaluateObject interface.)
Fixed a problem with the namespace object deletion mechanism for objects created by control methods. There were two parts to this problem: 1) Objects created during the initialization phase method parse were not being deleted, and 2) The object owner ID mechanism to track objects was broken.
Code and Data Size: Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Added basic PCI Interrupt Routing Table (PRT) support for IA32 (acpi_pci.c), and unified the PRT code for IA32 and IA64. This version supports both static and dyanmic PRT entries, but dynamic entries are treated as if they were static (not yet reconfigurable). Architecture- specific code to use this data is absent on IA32 but should be available shortly.
Changed the initialization sequence to start the ACPI interpreter (acpi_init) prior to initialization of the PCI driver (pci_init) in init/main.c. This ordering is required to support PRT and facilitate other (future) enhancement. A side effect is that the ACPI bus driver and certain device drivers can no longer be loaded as modules.
Updated Index support to match ACPI 2.0 semantics. Storing a Integer, String, or Buffer to an Index of a Buffer will store only the least-significant byte of the source to the Indexed buffer byte. Multiple writes are not performed.
The internal object cache is now purged after table loading and initialization to reduce the use of dynamic kernel memory -- on the assumption that object use is greatest during the parse phase of the entire table (versus the run-time use of individual control methods.)
Code and Data Size: Code and Data optimizations have permitted new feature development with an actual reduction in the library size. Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Enhanced the ACPI boot-time initialization code to allow the use of Local APIC tables for processor enumeration on IA-32, and to pave the way for a fully MPS-free boot (on SMP systems) in the near future. This functionality replaces arch/i386/kernel/acpitables.c, which was introduced in an earlier 2.4.15-preX release. To enable this feature you must add "acpi_boot=on" to the kernel command line -- see the help entry for CONFIG_ACPI_BOOT for more information. An IA-64 release is in the works...
Added additional typechecking for Fields within restricted access Operation Regions. All fields within EC and CMOS regions must be declared with ByteAcc. All fields withing SMBus regions must be declared with the BufferAcc access type.
Implemented ACPI 2.0-defined support for writes to fields with a Buffer, String, or Integer source operand that is smaller than the target field. In these cases, the source operand is zero-extended to fill the target field.
Fixed a problem where a Field starting bit offset (within the parent operation region) was calculated incorrectly if the alignment of the field differed from the access width. This affected CreateWordField, CreateDwordField, CreateQwordField, and possibly other fields that use the "AccessAny" keyword.
Fixed a problem introduced in the 11_02_01 release where indirect stores through method arguments did not operate correctly.
Implemented boot-time ACPI table parsing support (CONFIG_ACPI_BOOT) for IA32 and IA64 UP/SMP systems. This code facilitates the use of ACPI tables (e.g. MADT, SRAT) rather than legacy BIOS interfaces (e.g. MPS) for the configuration of system processors, memory, and interrupts during setup_arch(). Note that this patch does not include the required architecture-specific changes required to apply this information -- subsequent patches will be posted for both IA32 and IA64 to achieve this.
Added low-level sleep support for IA32 platforms, courtesy of Pat Mochel. This allows IA32 systems to transition to/from various sleeping states (e.g. S1, S3), although the lack of a centralized driver model and power-manageable drivers will prevent its (successful) use on most systems.
Revamped the ACPI 'menuconfig' layout: created new "ACPI Support" submenu, unified IA32 and IA64 options, added new "Boot using ACPI tables" option, etc.
Increased the default timeout for the EC driver from 1ms to 10ms (1000 cycles of 10us) to try to address AE_TIME errors during EC transactions.
OSL Interfaces: Several of the OSL (AcpiOs*) interfaces required changes to support ACPI 2.0 Qword field access. Read/Write PciConfiguration(), Read/Write Memory(), and Read/Write Port() now accept an ACPI_INTEGER (64 bits) as the value parameter. Also, the value parameter for the address space handler interface is now an ACPI_INTEGER. OSL implementations of these interfaces must now handle the case where the Width parameter is 64.
Index and Bank Fields: Nested Index and Bank Fields are now supported. During field access, a check is performed to ensure that the value written to an Index or Bank register is not out of the range of the register. The Index (or Bank) register is written before each access to the field data. Future support will include allowing individual IndexFields to be wider than the DataRegister width.
Fields: Fixed a problem where the AML interpreter was incorrectly attempting to write beyond the end of a Field/OpRegion. This was a boundary case that occurred when a DWORD field was written to a BYTE access OpRegion, forcing multiple writes and causing the interpreter to write one datum too many.
Fields: Fixed a problem with Field/OpRegion access where the starting bit address of a field was incorrectly calculated if the current access type was wider than a byte (WordAcc, DwordAcc, or QwordAcc).
Fields: Fixed a problem where forward references to individual FieldUnits (individual Field names within a Field definition) were not resolved during the AML table load.
Fields: Fixed a problem where forward references from a Field definition to the parent Operation Region definition were not resolved during the AML table load.
Fields: Duplicate FieldUnit names within a scope are now detected during AML table load.
Acpi Interfaces: Fixed a problem where the AcpiGetName() interface returned an incorrect name for the root node.
Code and Data Size: Code and Data optimizations have permitted new feature development with an actual reduction in the library size. Current core subsystem library sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the debug output trace mechanism and has a larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Previous Release (10_18_01):
Non-Debug Version: 63.9K Code, 5.1K Data, 69.0K Total
Debug Version: 136.7K Code, 57.4K Data, 194.2K Total
Fixed a problem with the internal object reference count mechanism that occasionally caused premature object deletion. This resolves all of the outstanding problem reports where an object is deleted in the middle of an interpreter evaluation. Although this problem only showed up in rather obscure cases, the solution to the problem involved an adjustment of all reference counts involving objects attached to namespace nodes.
Fixed a problem with Field support in the interpreter where writing to an aligned field whose length is an exact multiple (2 or greater) of the field access granularity would cause an attempt to write beyond the end of the field.
The top level AML opcode execution functions within the interpreter have been renamed with a more meaningful and consistent naming convention. The modules exmonad.c and exdyadic.c were eliminated. New modules are exoparg1.c, exoparg2.c, exoparg3.c, and exoparg6.c.
Fixed a problem where the AML debugger was causing some internal objects to not be deleted during subsystem termination.
Fixed a problem with the external AcpiEvaluateObject interface where the subsystem would fault if the named object to be evaluated refered to a constant such as Zero, Ones, etc.
Fixed a problem with IndexFields and BankFields where the subsystem would fault if the index, data, or bank registers were not defined in the same scope as the field itself.
Added printf format string checking for compilers that support this feature. Corrected more than 50 instances of issues with format specifiers within invocations of ACPI_DEBUG_PRINT throughout the core subsystem code.
The ASL "Revision" operator now returns the ACPI support level implemented in the core - the value "2" since the ACPI 2.0 support is more than 50% implemented.
Enhanced the output of the AML debugger "dump namespace" command to output in a more human-readable form.
Current core subsystem library code sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the full debug trace mechanism -- leading to a much larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Enhanced the /proc interface for the thermal zone driver and added support for _HOT (the critical suspend trip point). The 'info' file now includes threshold/policy information, and allows setting of _SCP (cooling preference) and _TZP (polling frequency) values to the 'info' file. Examples: "echo tzp=5 > info" sets the polling frequency to 5 seconds, and "echo scp=1 > info" sets the cooling preference to the passive/quiet mode (if supported by the ASL).
The AcpiEnableEvent and AcpiDisableEvent interfaces have been modified to allow individual GPE levels to be flagged as wake-enabled (i.e., these GPEs are to remain enabled when the platform sleeps.)
The AcpiEnterSleepState and AcpiLeaveSleepState interfaces now support wake-enabled GPEs. This means that upon entering the sleep state, all GPEs that are not wake-enabled are disabled. When leaving the sleep state, these GPEs are reenabled.
A local double-precision divide/modulo module has been added to enhance portability to OS kernels where a 64-bit math library is not available. The new module is "utmath.c".
Fixed a problem where the use of the ASL Revision operator returned an error. This operator now returns the current version of the ACPI CA core subsystem.
Fixed a problem where objects passed as control method parameters to AcpiEvaluateObject were always deleted at method termination. However, these objects may end up being stored into the namespace by the called method. The object reference count mechanism was applied to these objects instead of a force delete.
Fixed a problem where static strings or buffers (contained in the AML code) that are declared as package elements within the ASL code could cause a fault because the interpreter would attempt to delete them. These objects are now marked with the "static object" flag to prevent any attempt to delete them.
Implemented an interpreter optimization to use operands directly from the state object instead of extracting the operands to local variables. This reduces stack use and code size, and improves performance.
The module exxface.c was eliminated as it was an unnecessary extra layer of code.
Current core subsystem library code sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the full debug trace mechanism -- leading to a much larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
Non-Debug Version: 65K Code, 5K Data, 70K Total (Previously 69K) Debug Version: 138K Code, 58K Data, 196K Total (Previously 195K)
Linux:
Support for ACPI 2.0 64-bit integers has been added. All ACPI Integer objects are now 64 bits wide
All Acpi data types and structures are now in lower case. Only Acpi macros are upper case for differentiation.
Documentation:
Changes to the external interfaces as described above.
A bug with interpreter implementation of the ASL Divide operator was found and fixed. The implicit function return value (not the explicit store operands) was returning the remainder instead of the quotient. This was a longstanding bug and it fixes several known outstanding issues on various platforms.
The ACPI_DEBUG_PRINT and function trace entry/exit macros have been further optimized for size. There are 700 invocations of the DEBUG_PRINT macro alone, so each optimization reduces the size of the debug version of the subsystem significantly.
A stack trace mechanism has been implemented. The maximum stack usage is about 2K on 32-bit platforms. The debugger command "stat stack" will display the current maximum stack usage.
All public symbols and global variables within the subsystem are now prefixed with the string "Acpi". This keeps all of the symbols grouped together in a kernel map, and avoids conflicts with other kernel subsystems.
Current core subsystem library code sizes are shown below. These are the code and data sizes for the acpica.lib produced by the Microsoft Visual C++ 6.0 compiler, and these values do not include any ACPI driver or OSPM code. The debug version of the code includes the full debug trace mechanism which contains over 700 invocations of the DEBUG_PRINT macro, 500 function entry macro invocations, and over 900 function exit macro invocations -- leading to a much larger code and data size. Note that these values will vary depending on the efficiency of the compiler and the compiler options used during generation.
The following ACPI 2.0 ASL operators have been implemented in the AML interpreter (These are already supported by the Intel ASL compiler): ToDecimalString, ToHexString, ToString, ToInteger, and ToBuffer. Support for 64-bit AML constants is implemented in the AML parser, debugger, and disassembler.
The internal memory tracking mechanism (leak detection code) has been upgraded to reduce the memory overhead (a separate tracking block is no longer allocated for each memory allocation), and now supports all of the internal object caches.
The data structures and code for the internal object caches have been coelesced and optimized so that there is a single cache and memory list data structure and a single group of functions that implement generic cache management. This has reduced the code size in both the debug and release versions of the subsystem.
The DEBUG_PRINT macro(s) have been optimized for size and replaced by ACPI_DEBUG_PRINT. The syntax for this macro is slightly different, because it generates a single call to an internal function. This results in a savings of about 90 bytes per invocation, resulting in an overall code and data savings of about 16% in the debug version of the subsystem.
Added a new interface named AcpiGetFirmwareTable to obtain any ACPI table via the ACPI signature. The interface can be called at any time during kernel initialization, even before the kernel virtual memory manager is initialized and paging is enabled. This allows kernel subsystems to obtain ACPI tables very early, even before the ACPI CA subsystem is initialized.
Fixed a problem where Fields defined with the AnyAcc attribute could be resolved to the incorrect address under the following conditions: 1) the field width is larger than 8 bits and 2) the parent operation region is not defined on a DWORD boundary.
Fixed a problem where the interpreter is not being locked during namespace initialization (during execution of the _INI control methods), causing an error when an attempt is made to release it later.
ACPI 2.0 support in the AML Interpreter has begun and will be ongoing throughout the rest of this year. In this label, The Mod operator is implemented.
Added a new data type to contain full PCI addresses named ACPI_PCI_ID. This structure contains the PCI Segment, Bus, Device, and Function values.
Linux:
Enhanced the Linux version of the source code to change most capitalized ACPI type names to lowercase. For example, all instances of ACPI_STATUS are changed to acpi_status. This will result in a large diff, but the change is strictly cosmetic and aligns the CA code closer to the Linux coding standard.
The interfaces to the PCI configuration space have been changed to add the PCI Segment number and to split the single 32-bit combined DeviceFunction field into two 16-bit fields. This was accomplished by moving the four values that define an address in PCI configuration space (segment, bus, device, and function) to the new ACPI_PCI_ID structure.
The changes to the PCI configuration space interfaces led to a reexamination of the complete set of address space access interfaces for PCI, I/O, and Memory. The previously existing 18 interfaces have proven difficult to maintain (any small change must be propagated across at least 6 interfaces) and do not easily allow for future expansion to 64 bits if necessary. Also, on some systems, it would not be appropriate to demultiplex the access width (8, 16, 32,or 64) before calling the OSL if the corresponding native OS interfaces contain a similar access width parameter. For these reasons, the 18 address space interfaces have been replaced by these 6 new ones:
Added a new interface named AcpiOsGetRootPointer to allow the OSL to perform the platform and/or OS-specific actions necessary to obtain the ACPI RSDP table pointer. On IA-32 platforms, this interface will simply call down to the CA core to perform the low-memory search for the table. On IA-64, the RSDP is obtained from EFI. Migrating this interface to the OSL allows the CA core to remain OS and platform independent.
Added a new interface named AcpiOsSignal to provide a generic "function code and pointer" interface for various miscellaneous signals and notifications that must be made to the host OS. The first such signals are intended to support the ASL Fatal and Breakpoint operators. In the latter case, the AcpiOsBreakpoint interface has been obsoleted.
The definition of the AcpiFormatException interface has been changed to simplify its use. The caller no longer must supply a buffer to the call; A pointer to a const string is now returned directly. This allows the call to be easily used in printf statements, etc. since the caller does not have to manage a local buffer.
The ACPI 2.0 Switch/Case/Default operators have been implemented and are fully functional. They will work with all ACPI 1.0 interpreters, since the operators are simply translated to If/Else pairs.
Implemented support for ACPI 2.0 variable-length packages. These packages have a separate opcode, and their size is determined by the interpreter at run-time.
Fixed a problem where a DWORD-accessed field within a Buffer object would get its byte address inadvertently rounded down to the nearest DWORD. Buffers are always Byte-accessible.
Fixed a problem where the Switch() operator would either fault or hang the compiler. Note however, that the AML code for this ACPI 2.0 operator is not yet implemented.
Implementation of the CreateField operator automatically converts a reference to a named field within a resource descriptor from a byte offset to a bit offset if required.
Added some missing named fields from the resource descriptor support. These are the names that are automatically created by the compiler to reference fields within a descriptor. They are only valid at compile time and are not passed through to the AML interpreter.
Fixed a couple of problems in the Field support code where bits from adjacent fields could be returned along with the proper field bits. Restructured the field support code to improve performance, readability and maintainability.
New DEBUG_PRINTP macro automatically inserts the procedure name into the output, saving hundreds of copies of procedure name strings within the source, shrinking the memory footprint of the debug version of the core subsystem.
Source Code Structure:
The source code directory tree was restructured to reflect the current organization of the component architecture. Some files and directories have been moved and/or renamed.
Memory allocation performance enhancement - over 24X compile time improvement on large ASL files. Parse nodes and namestring buffers are now allocated from a large internal compiler buffer.
Added error detection for ASL Fields that extend beyond the length of the parent operation region (only if the length of the region is known at compile time.) This includes fields that have a minimum access width that is smaller than the parent region, and individual field units that are partially or entirely beyond the extent of the parent.
Added optional thread ID output for debug traces, to simplify debugging of multiple threads. Added context switch notification when the debug code realizes that a different thread is now executing ACPI code.
Some additional external data types have been prefixed with the string "ACPI_" for consistency. This may effect existing code. The data types affected are the external callback typedefs - e.g., WALK_CALLBACK becomes ACPI_WALK_CALLBACK.
Restructured support for BufferFields and RegionFields. BankFields support is now fully operational. All known 32-bit limitations on field sizes have been removed. Both BufferFields and (Operation) RegionFields are now supported by the same field management code.
Resource support now supports QWORD address and IO resources. The 16/32/64 bit address structures and the Extended IRQ structure have been changed to properly handle Source Resource strings.
A ThreadId of -1 is now used to indicate a "mutex not acquired" condition internally and must never be returned by AcpiOsThreadId. This reserved value was changed from 0 since Unix systems allow a thread ID of 0.
Notify handler fix - notifies are deferred until the parent method completes execution. This fixes the "mutex already acquired" issue seen occasionally.
Part of the "implicit conversion" rules in ACPI 2.0 have been found to cause compatibility problems with existing ASL/AML. The convert "result-to-target-type" implementation has been removed for stores to method Args and Locals. Source operand conversion is still fully implemented. Possible changes to ACPI 2.0 specification pending.
Module dependencies not currently implemented. If used, they should be loaded in this order: busmgr, power, ec, system, processor, battery, ac_adapter, button, thermal.
Added a new OSL Interface, AcpiOsGetThreadId. This was required for the deadlock detection code. Defined to return a non-zero, 32-bit thread ID for the currently executing thread. May be a non-zero constant integer on single-thread systems.
Implemented deadlock detection for internal subsystem mutexes. We may add conditional compilation for this code (debug only) later.
ASL/AML Mutex object semantics are now fully supported. This includes multiple acquires/releases by owner and support for the Mutex SyncLevel parameter.
A new "Force Release" mechanism automatically frees all ASL Mutexes that have been acquired but not released when a thread exits the interpreter. This forces conformance to the ACPI spec ("All mutexes must be released when an invocation exits") and prevents deadlocked ASL threads. This mechanism can be expanded (later) to monitor other resource acquisitions if OEM ASL code continues to misbehave (which it will).
Recursive method calls are now allowed and supported (the ACPI spec does in fact allow recursive method calls.) The number of recursive calls is subject to the restrictions imposed by the SERIALIZED method keyword and SyncLevel (ACPI 2.0) method parameter.
Fixed a problem where the length of a String package element was not always included in the length of the overall package returned from AcpiEvaluateObject.
Added external interfaces (Acpi*) to the ACPI debug memory manager. This manager keeps a list of all outstanding allocations, and can therefore detect memory leaks and attempts to free memory blocks more than once. Useful for code such as the power manager, etc. May not be appropriate for device drivers. Performance with the debug code enabled is slow.
Core ACPI CA Subsystem: Fixed a problem where an error was incorrectly returned if the return resource buffer was larger than the actual data (in the resource interfaces).
References to named objects within packages are resolved to the full pathname string before packages are returned directly (via the AcpiEvaluateObject interface) or indirectly via the resource interfaces.
All defined method arguments can now be used as local variables, including the ones that are not actually passed in as parameters. The compiler tracks initialization of the arguments and issues an exception if they are used without prior assignment (just like locals).
The -o option now specifies a filename prefix that is used for all output files, including the AML output file. Otherwise, the default behavior is as follows: 1) the AML goes to the file specified in the DSDT. 2) all other output files use the input source filename as the base.
Core ACPI CA Subsystem: Restructured the implementation of object store support within the interpreter. This includes support for the Store operator as well as any ASL operators that include a target operand.
Partially implemented support for Implicit Result-to-Target conversion. This is when a result object is converted on the fly to the type of an existing target object. Completion of this support is pending further analysis of the ACPI specification concerning this matter.
ASL Compiler: Version X2013: Fixed a problem where the line numbering and error reporting could get out of sync in the presence of multiple include files.
Implemented support for type conversions in the execution of the ASL Concatenate operator (The second operand is converted to match the type of the first operand before concatenation.)
Support for implicit source operand conversion is partially implemented. The ASL source operand types Integer, Buffer, and String are freely interchangeable for most ASL operators and are converted by the interpreter on the fly as required. Implicit Target operand conversion (where the result is converted to the target type before storing) is not yet implemented.
New exception, AE_AML_NO_RETURN_VALUE, is returned when a method does not return a value, but the caller expects one. (The ASL compiler flags this as a warning.)
1. Static typechecking of all operands is implemented. This prevents the use of invalid objects (such as using a Package where an Integer is required) at compile time instead of at interpreter run-time.
2. The ASL source line is printed with ALL errors and warnings.
3. Bug fix for source EOF without final linefeed.
4. Debug option is split into a parse trace and a namespace trace.
5. Namespace output option (-n) includes initial values for integers and strings.
6. Parse-only option added for quick syntax checking.
7. Compiler checks for duplicate ACPI name declarations
1. Relaxed typechecking to allow interchangeability between strings, integers, and buffers. These types are now converted by the interpreter at runtime.
2. Compiler reports time taken by each internal subsystem in the debug output file.
Fixed a problem where named references within the ASL definition of both OperationRegions and CreateXXXFields did not work properly. The symptom was an AE_AML_OPERAND_TYPE during initialization of the region/field. This is similar (but not related internally) to the problem that was fixed in the last label.
Fixed a problem where method invocations within the ASL definition of both OperationRegions and CreateXXXFields did not work properly. The symptom was an AE_AML_OPERAND_TYPE during initialization of the region/field:
Fixed a problem where operators with more than one nested subexpression would fail. The symptoms were varied, by mostly AE_AML_OPERAND_TYPE errors. This was actually a rather serious problem that has gone unnoticed until now.
Fixed a problem where Operation Region initialization failed if the operation region name was a "namepath" instead of a simple "nameseg". Symptom was an AE_NO_OPERAND error.
Fixed a problem where an assignment to a local variable via the indirect RefOf mechanism only worked for the first such assignment. Subsequent assignments were ignored.
ACPI 2.0 table support with backwards support for ACPI 1.0 and the 0.71 extensions. Note: although we can read ACPI 2.0 BIOS tables, the AML interpreter does NOT have support for the new 2.0 ASL grammar terms at this time.
New table initialization interfaces: AcpiInitializeSubsystem no longer has any parameters AcpiFindRootPointer - Find the RSDP (if necessary) AcpiLoadTables (RSDP) - load all tables found at RSDP->RSDT Obsolete Interfaces AcpiLoadFirmwareTables - replaced by AcpiLoadTables
The new initialization architecture is implemented. New interfaces are: AcpiInitializeSubsystem (replaces AcpiInitialize) AcpiEnableSubsystem Obsolete Interfaces: AcpiLoadNamespace (Namespace is automatically loaded when a table is loaded)
The ACPI_OPERAND_OBJECT has been optimized to shrink its size from 52 bytes to 32 bytes. There is usually one of these for every namespace object, so the memory savings is significant.
The so-called "third pass parse" has been replaced by a final walk through the namespace to initialize all operation regions (address spaces) and fields that have not yet been initialized during the execution of the various _INI and REG methods.
Namespace manager data structures have been reworked to change the primary object from a table to a single object. This has resulted in dynamic memory savings of 3X within the namespace and 2X overall in the ACPI CA subsystem.
Revision numbers added to each module header showing the SourceSafe version of the file. Please refer to this version number when giving us feedback or comments on individual modules.
Parser/Interpreter integration: Eliminated the creation of complete parse trees for ACPI tables and control methods. Instead, parse subtrees are created and then deleted as soon as they are processed (Either entered into the namespace or executed by the interpreter). This reduces the use of dynamic kernel memory significantly. (about 10X)
Exception codes broken into classes and renumbered. Be sure to recompile all code that includes acexcep.h. Hopefully we won't have to renumber the codes again now that they are split into classes (environment, programmer, AML code, ACPI table, and internal).
Fixed some additional alignment issues in the Resource Manager subcomponent
Implemented semaphore tracking in the AcpiExec utility, and fixed several places where mutexes/semaphores were being unlocked without a corresponding lock operation. There are no known semaphore or mutex "leaks" at this time.
Fixed the case where an ASL Return operator is used to return an unnamed package.
Fixed a problem with the way addresses were calculated in AcpiAmlReadFieldData() and AcpiAmlWriteFieldData(). This problem manifested itself when a Field was created with WordAccess or DwordAccess, but the field unit defined within the Field was less than a Word or Dword.
Fixed a problem in AmlDumpOperands() module's loop to pull operands off of the operand stack to display information. The problem manifested itself as a TLB error on 64-bit systems when accessing an operand stack with two or more operands.
Fixed a problem with the PCI configuration space handlers where context was getting confused between accesses. This required a change to the generic address space handler and address space setup definitions. Handlers now get both a global handler context (this is the one passed in by the user when executing AcpiInstallAddressSpaceHandler() and a specific region context that is unique to each region (For example, the _ADR, _SEG and _BBN values associated with a specific region). The generic function definitions have changed to the following:
typedef ACPI_STATUS (*ADDRESS_SPACE_HANDLER) ( UINT32 Function, UINT32 Address, UINT32 BitWidth, UINT32 *Value, void *HandlerContext, // This used to be void *Context void *RegionContext); // This is an additional parameter
typedef ACPI_STATUS (*ADDRESS_SPACE_SETUP) ( ACPI_HANDLE RegionHandle, UINT32 Function, void *HandlerContext, void **RegionContext); // This used to be **ReturnContext
Major file consolidation and rename. All files within the interpreter have been renamed as well as most header files. This was done to prevent collisions with existing files in the host OSs -- filenames such as "config.h" and "global.h" seem to be quite common. The VC project files have been updated. All makefiles will require modification.
The parser/interpreter integration continues in Phase 5 with the implementation of a complete 2-pass parse (the AML is parsed twice) for each table; This avoids the construction of a huge parse tree and therefore reduces the amount of dynamic memory required by the subsystem. Greater use of the parse object cache means that performance is unaffected.
With a nod and a tip of the hat to the technology of yesteryear, we've added support in the source code for 80 column output devices. The code is now mostly constrained to 80 columns or less to support environments and editors that 1) cannot display or print more than 80 characters on a single line, and 2) cannot disable line wrapping.
A major restructuring of the namespace data structure has been completed. The result is 1) cleaner and more understandable/maintainable code, and 2) a significant reduction in the dynamic memory requirement for each named ACPI object (almost half).
Linux support has been added. In order to obtain approval to get the ACPI CA subsystem into the Linux kernel, we've had to make quite a few changes to the base subsystem that will affect all users (all the changes are generic and OS- independent). The effects of these global changes have been somewhat far reaching. Files have been merged and/or renamed and interfaces have been renamed. The major changes are described below.
Osd* interfaces renamed to AcpiOs* to eliminate namespace pollution/confusion within our target kernels. All OSD interfaces must be modified to match the new naming convention.
Files merged across the subsystem. A number of the smaller source and header files have been merged to reduce the file count and increase the density of the existing files. There are too many to list here. In general, makefiles that call out individual files will require rebuilding.
Interpreter files renamed. All interpreter files now have the prefix am* instead of ie* and is*.
Header files renamed: The acapi.h file is now acpixf.h. The acpiosd.h file is now acpiosxf.h. We are removing references to the acronym "API" since it is somewhat windowsy. The new name is "external interface" or xface or xf in the filenames.j
All manifest constants have been forced to upper case (some were mixed case.) Also, the string "ACPI_" has been prepended to many (not all) of the constants, typedefs, and structs.
The globals "DebugLevel" and "DebugLayer" have been renamed "AcpiDbgLevel" and "AcpiDbgLayer" respectively.
All other globals within the subsystem are now prefixed with "AcpiGbl_" Internal procedures within the subsystem are now prefixed with "Acpi" (with only a few exceptions). The original two-letter abbreviation for the subcomponent remains after "Acpi" - for example, CmCallocate became AcpiCmCallocate.
Added a source code translation/conversion utility. Used to generate the Linux source code, it can be modified to generate other types of source as well. Can also be used to cleanup existing source by removing extraneous spaces and blank lines. Found in tools/acpisrc/*
OsdUnMapMemory was renamed to OsdUnmapMemory and then AcpiOsUnmapMemory. (UnMap became Unmap).
A "MaxUnits" parameter has been added to AcpiOsCreateSemaphore. When set to one, this indicates that the caller wants to use the semaphore as a mutex, not a counting semaphore. ACPI CA uses both types. However, implementers of this call may want to use different OS primitives depending on the type of semaphore requested. For example, some operating systems provide separate "mutex" and "semaphore" interfaces - where the mutex interface is much faster because it doesn't have all the overhead of a full semaphore implementation.
Fixed a deadlock problem where a method that accesses the PCI address space can block forever if it is the first access to the space.
Support for environments that cannot handle unaligned data accesses (e.g. firmware and OS environments devoid of alignment handler technology namely SAL/EFI and the IA-64 Linux kernel) has been added (via configurable macros) in these three areas: - Transfer of data from the raw AML byte stream is done via byte moves instead of word/dword/qword moves. - External objects are aligned within the user buffer, including package elements (sub-objects). - Conversion of name strings to UINT32 Acpi Names is now done byte-wise.
The Store operator was modified to mimic Microsoft's implementation when storing to a Buffer Field.
