diff options
| author | Naresh Bhat <naresh.bhat@linaro.org> | 2013-07-31 18:49:05 +0530 |
|---|---|---|
| committer | Riku Voipio <riku.voipio@linaro.org> | 2013-08-02 11:59:45 +0300 |
| commit | f513285d790bcac330a4bfd877af6a271c16a376 (patch) | |
| tree | e5fae38473055c4b53e5df6fbb82561e3d5a08e4 /meta-linaro/recipes-extra | |
| parent | 20c99e65e979400aa9ecb9b985d1d977506165c4 (diff) | |
Fix acpica recipe
Fix SRC_URI path along with compilation bugfix patches
on aarch64 architecture.
Signed-off-by: Naresh Bhat <naresh.bhat@linaro.org>
Signed-off-by: Riku Voipio <riku.voipio@linaro.org>
Diffstat (limited to 'meta-linaro/recipes-extra')
8 files changed, 3310 insertions, 5 deletions
diff --git a/meta-linaro/recipes-extra/acpica/acpica_20130626.bb b/meta-linaro/recipes-extra/acpica/acpica_20130626.bb index 65eadac0..230ab4da 100644 --- a/meta-linaro/recipes-extra/acpica/acpica_20130626.bb +++ b/meta-linaro/recipes-extra/acpica/acpica_20130626.bb @@ -13,16 +13,22 @@ DEPENDS="bison \ flex" COMPATIBLE_HOST = "(i.86|x86_64|arm|aarch64).*-linux" -PR="r1" +PR="r2" -SRC_URI="https://acpica.org/sites/acpica/files/acpica-unix2-${PV}.tar.gz \ +SRC_URI="git://git.linaro.org/people/ahs3/acpica-tools.git \ + file://fix_ftbfs_debian-kfreebsd.patch \ + file://debian-big_endian.patch \ + file://debian-unaligned.patch \ + file://fix_ftbfs_debian-hurd.patch \ + file://add-testing.patch \ + file://name-miscompare.patch \ + file://aapits-linux.patch \ file://cross-compile.patch \ file://no-werror.patch" -SRC_URI[md5sum] = "b7112b3deffef8fe25aac7810cc419a9" -SRC_URI[sha256sum] = "888dda6227265c396a686624f971c51693c2bba84f24c634536234c8dca7b465" +SRCREV = "${AUTOREV}" -S="${WORKDIR}/acpica-unix2-${PV}" +S = "${WORKDIR}/git" EXTRA_OEMAKE = "'OPT_CFLAGS=-Wall'" diff --git a/meta-linaro/recipes-extra/acpica/files/aapits-linux.patch b/meta-linaro/recipes-extra/acpica/files/aapits-linux.patch new file mode 100644 index 00000000..79bbaffa --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/aapits-linux.patch @@ -0,0 +1,530 @@ +diff -urN acpica-unix2-20130626/tests/aapits/atexec.c acpica-unix2-20130626-aapits/tests/aapits/atexec.c +--- acpica-unix2-20130626/tests/aapits/atexec.c 2013-01-17 12:48:28.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/atexec.c 2013-07-25 13:44:23.023894441 -0600 +@@ -530,6 +530,7 @@ + } + + ++#if ACPI_MACHINE_WIDTH == 32 + /******************************************************************************* + * + * FUNCTION: AtBuildLocalRSDT +@@ -648,8 +649,9 @@ + LocalRSDT->Header.Checksum = (UINT8)~LocalRSDT->Header.Checksum; + } + } ++#endif + + + /******************************************************************************* + * + * FUNCTION: AtBuildLocalXSDT +@@ -1315,7 +1319,7 @@ + ACPI_WARNING ((AE_INFO, + "Request on [%4.4s] is beyond region limit Req-%X+%X, Base=%X, Len-%X\n", + (RegionObject->Region.Node)->Name.Ascii, (UINT32) Address, +- ByteWidth, (UINT32) BufferAddress, Length)); ++ ByteWidth, (UINT32) BufferAddress, (UINT32) Length)); + + return (AE_AML_REGION_LIMIT); + } +@@ -1683,7 +1687,9 @@ + Path, Obj.Integer.Value, Value); + #else + printf ("API Error: Value of %s is 0x%llx instead of expected 0x%llx\n", +- Path, Obj.Integer.Value, Value); ++ Path, ++ (long long unsigned int) Obj.Integer.Value, ++ (long long unsigned int) Value); + #endif + Status = AE_ERROR; + } +@@ -1762,7 +1768,7 @@ + { + TestErrors++; + printf ("Test Error: cannot allocate buffer of %d bytes\n", +- Results.Length); ++ (int) Results.Length); + return (AE_NO_MEMORY); + } + Results.Pointer = Object; +@@ -1843,7 +1849,8 @@ + { + printf ("AtCheckBuffer: unexpected length %d of Buffer vs" + " calculated %d bytes\n", +- Results.Length, ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof (ACPI_OBJECT) + Length)); ++ (int)Results.Length, ++ (int)(ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof (ACPI_OBJECT) + Length))); + } + + /* Initialize the return buffer structure */ +@@ -1852,7 +1859,7 @@ + { + TestErrors++; + printf ("Test Error: cannot allocate buffer of %d bytes\n", +- Results.Length); ++ (int) Results.Length); + return (AE_NO_MEMORY); + } + Results.Pointer = Object; +diff -urN acpica-unix2-20130626/tests/aapits/atinit.c acpica-unix2-20130626-aapits/tests/aapits/atinit.c +--- acpica-unix2-20130626/tests/aapits/atinit.c 2013-01-17 12:48:28.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/atinit.c 2013-07-25 13:20:19.706705960 -0600 +@@ -2915,7 +2915,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetSystemInfo() returned" + " Length %d, expected %d\n", +- OutBuffer.Length, sizeof (Info)); ++ (int) OutBuffer.Length, (int) sizeof (Info)); + return (AE_ERROR); + } + +@@ -2937,7 +2937,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetSystemInfo() returned" + " Length %d, expected %d\n", +- OutBuffer.Length, sizeof (Info)); ++ (int) OutBuffer.Length, (int) sizeof (Info)); + return (AE_ERROR); + } + +@@ -2957,7 +2957,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetSystemInfo() returned" + " Length %d, expected %d\n", +- OutBuffer.Length, sizeof (Info)); ++ (int) OutBuffer.Length, (int) sizeof (Info)); + return (AE_ERROR); + } + else if (OutBuffer.Pointer != &Info) +@@ -3040,7 +3040,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetSystemInfo() returned" + " Length %d, expected %d\n", +- OutBuffer.Length, sizeof (Info)); ++ (int) OutBuffer.Length, (int) sizeof (Info)); + return (AE_ERROR); + } + else if (OutBuffer.Pointer != &Info) +@@ -3105,7 +3105,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetSystemInfo() returned" + " Length %d, expected %d\n", +- OutBuffer.Length, sizeof (ACPI_SYSTEM_INFO)); ++ (int) OutBuffer.Length, (int) sizeof (ACPI_SYSTEM_INFO)); + return (AE_ERROR); + } + else +diff -urN acpica-unix2-20130626/tests/aapits/atmain.c acpica-unix2-20130626-aapits/tests/aapits/atmain.c +--- acpica-unix2-20130626/tests/aapits/atmain.c 2013-01-17 12:48:28.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/atmain.c 2013-07-25 13:18:22.083323948 -0600 +@@ -206,7 +206,7 @@ + { + printf ("ACPICA API TS err: test num %ld of test case %ld" + " is not implemented\n", +- test_num, test_case); ++ (long int) test_num, (long int) test_case); + return (AtRetNotImpl); + } + +@@ -321,7 +323,7 @@ + if (test_case < 1 || test_case > AT_TEST_CASE_NUM) + { + printf ("ACPICA API TS err: test case %ld is out of range 1 - %d\n", +- test_case, AT_TEST_CASE_NUM); ++ (long int) test_case, (int) AT_TEST_CASE_NUM); + return (AtRetBadParam); + } + +@@ -329,7 +331,7 @@ + if (test_num < 0 || test_num > AtTestCase[test_case].TestsNum) + { + printf ("ACPICA API TS err: test num %ld is out of range 0 - %d\n", +- test_num, AtTestCase[test_case].TestsNum); ++ (long int) test_num, AtTestCase[test_case].TestsNum); + return (AtRetBadParam); + } + +diff -urN acpica-unix2-20130626/tests/aapits/atnamespace.c acpica-unix2-20130626-aapits/tests/aapits/atnamespace.c +--- acpica-unix2-20130626/tests/aapits/atnamespace.c 2013-01-17 12:48:28.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/atnamespace.c 2013-07-25 13:24:15.366466707 -0600 +@@ -2426,7 +2426,8 @@ + #else + printf ("API Error: Address of %s (0x%llX) != (0x%llX)\n", + PathNames[2 * i + 1], +- Info->Address, ExpectedInfo[i].Address); ++ (long long unsigned int) Info->Address, ++ (long long unsigned int) ExpectedInfo[i].Address); + #endif + #else + printf ("API Error: Address of %s (0x%X) != (0x%X)\n", +@@ -2799,7 +2800,8 @@ + TestErrors++; + printf ("AtGetNextObjectTypeCommon: different numbers of entities" + "in TypesNames (%d) and LevelTypes0000 (%d)\n", +- TypesCount, sizeof (LevelTypes0000) / sizeof (ACPI_OBJECT_TYPE)); ++ TypesCount, ++ (int) (sizeof (LevelTypes0000) / sizeof (ACPI_OBJECT_TYPE))); + return (AE_ERROR); + } + +@@ -4083,7 +4085,9 @@ + Pathname, Obj.Integer.Value, Value); + #else + printf ("API Error: Value of %s is 0x%llx instead of expected 0x%llx\n", +- Pathname, Obj.Integer.Value, Value); ++ Pathname, ++ (long long unsigned int) Obj.Integer.Value, ++ (long long unsigned int) Value); + #endif + Status = AE_ERROR; + } +@@ -5090,7 +5094,7 @@ + { + AapiErrors++; + printf ("API Error: AcpiOsAllocate(%d) returned NULL\n", +- OutName.Length); ++ (int) OutName.Length); + return (AE_ERROR); + } + } +diff -urN acpica-unix2-20130626/tests/aapits/atosxfctrl.c acpica-unix2-20130626-aapits/tests/aapits/atosxfctrl.c +--- acpica-unix2-20130626/tests/aapits/atosxfctrl.c 2013-01-17 12:48:28.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/atosxfctrl.c 2013-07-25 13:30:00.375492751 -0600 +@@ -622,13 +622,15 @@ + #if ACPI_MACHINE_WIDTH == 64 + #ifdef _MSC_VER + printf("OsxfCtrlFingReg: unexpected Width %d of Reg 0x%I64x\n", ++ Width, Address); + #else + printf("OsxfCtrlFingReg: unexpected Width %d of Reg 0x%llx\n", ++ Width, (long long unsigned int) Address); + #endif + #else + printf("OsxfCtrlFingReg: unexpected Width %d of Reg 0x%x\n", +-#endif + Width, Address); ++#endif + return (NULL); + } + +@@ -649,15 +651,19 @@ + #ifdef _MSC_VER + printf("OsxfCtrlFingReg: intersection Regs (0x%I64x: 0x%x)" + " and (0x%I64x: 0x%x)\n", ++ Reg->Address, Reg->Width, Address, Width); + #else + printf("OsxfCtrlFingReg: intersection Regs (0x%llx: 0x%x)" + " and (0x%llx: 0x%x)\n", ++ (long long unsigned int) Reg->Address, ++ Reg->Width, ++ (long long unsigned int) Address, Width); + #endif + #else + printf("OsxfCtrlFingReg: intersection Regs (0x%x: 0x%x)" + " and (0x%x: 0x%x)\n", +-#endif + Reg->Address, Reg->Width, Address, Width); ++#endif + return (NULL); + } + } +@@ -671,13 +677,15 @@ + #if ACPI_MACHINE_WIDTH == 64 + #ifdef _MSC_VER + printf("OsxfCtrlFingReg: no memory for Reg (0x%I64x: 0x%x)\n", ++ Reg->Address, Reg->Width); + #else + printf("OsxfCtrlFingReg: no memory for Reg (0x%llx: 0x%x)\n", ++ (long long unsigned int) Reg->Address, Reg->Width); + #endif + #else + printf("OsxfCtrlFingReg: no memory for Reg (0x%x: 0x%x)\n", +-#endif + Reg->Address, Reg->Width); ++#endif + return (NULL); + } + Reg->Type = Type; +@@ -817,14 +825,19 @@ + #if ACPI_MACHINE_WIDTH == 64 + #ifdef _MSC_VER + printf("%.2u (%s Address 0x%I64x: Width %.2u) r/w counts: %u/%u\n", ++ i, (Reg->Type == EMUL_REG_SYS)? "SYS": "IO", ++ Reg->Address, Reg->Width, Reg->ReadCount, Reg->WriteCount); + #else + printf("%.2u (%s Address 0x%llx: Width %.2u) r/w counts: %u/%u\n", ++ i, (Reg->Type == EMUL_REG_SYS)? "SYS": "IO", ++ (long long unsigned int) Reg->Address, ++ Reg->Width, Reg->ReadCount, Reg->WriteCount); + #endif + #else + printf("%.2u (%s Address 0x%.4x: Width %.2u) r/w counts: %u/%u\n", +-#endif + i, (Reg->Type == EMUL_REG_SYS)? "SYS": "IO", + Reg->Address, Reg->Width, Reg->ReadCount, Reg->WriteCount); ++#endif + Reg = Reg->Next; + i++; + } +diff -urN acpica-unix2-20130626/tests/aapits/atresource.c acpica-unix2-20130626-aapits/tests/aapits/atresource.c +--- acpica-unix2-20130626/tests/aapits/atresource.c 2013-01-17 12:48:29.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/atresource.c 2013-07-25 13:25:49.423565947 -0600 +@@ -65,7 +65,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetCurrentResources(%s) returned Length %d," + " expected %d\n", +- Pathname, OutBuffer.Length, RT0000_DEV0_CRS_LEN); ++ Pathname, (int) OutBuffer.Length, RT0000_DEV0_CRS_LEN); + return (AE_ERROR); + } + +@@ -381,7 +381,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetCurrentResources(%s) returned Length %d," + " expected %d\n", +- Pathname, OutBuffer.Length, RT0000_DEV0_CRS_LEN); ++ Pathname, (int) OutBuffer.Length, RT0000_DEV0_CRS_LEN); + return (AE_ERROR); + } + +@@ -580,7 +580,7 @@ + AapiErrors++; + printf ("Api Error: Resource->Length (%d) != %d\n", + CurrentResource->Length, +- ACPI_ROUND_UP_TO_NATIVE_WORD (ACPI_RS_SIZE (ACPI_RESOURCE_IRQ))); ++ (int) (ACPI_ROUND_UP_TO_NATIVE_WORD (ACPI_RS_SIZE (ACPI_RESOURCE_IRQ)))); + } + + if (CurrentResource->Data.Irq.Triggering != 0) /* Level-Triggered */ +@@ -872,7 +872,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetPossibleResources(%s) returned Length %d," + " expected %d\n", +- Pathname, OutBuffer.Length, RT0000_DEV0_CRS_LEN); ++ Pathname, (int) OutBuffer.Length, RT0000_DEV0_CRS_LEN); + return (AE_ERROR); + } + +@@ -1814,7 +1814,7 @@ + AapiErrors++; + printf ("API Error: AcpiGetIrqRoutingTable(%s) returned Length %d," + " expected %d\n", +- Pathname, OutBuffer.Length, 0xA48); ++ Pathname, (int) OutBuffer.Length, 0xA48); + return (AE_ERROR); + } + +diff -urN acpica-unix2-20130626/tests/aapits/Makefile acpica-unix2-20130626-aapits/tests/aapits/Makefile +--- acpica-unix2-20130626/tests/aapits/Makefile 2013-01-17 12:48:29.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/Makefile 2013-07-25 15:17:09.309236422 -0600 +@@ -20,37 +20,52 @@ + ../../source/components/hardware/hwxface.c \ + ../../source/common/getopt.c \ + ../../source/components/debugger/dbcmds.c \ ++ ../../source/components/debugger/dbconvert.c \ + ../../source/components/debugger/dbdisply.c \ + ../../source/components/debugger/dbexec.c \ + ../../source/components/debugger/dbfileio.c \ + ../../source/components/debugger/dbhistry.c \ + ../../source/components/debugger/dbinput.c \ ++ ../../source/components/debugger/dbmethod.c \ ++ ../../source/components/debugger/dbnames.c \ + ../../source/components/debugger/dbstats.c \ + ../../source/components/debugger/dbutils.c \ + ../../source/components/debugger/dbxface.c \ + ../../source/components/disassembler/dmbuffer.c \ ++ ../../source/components/disassembler/dmdeferred.c \ + ../../source/components/disassembler/dmnames.c \ + ../../source/components/disassembler/dmobject.c \ + ../../source/components/disassembler/dmopcode.c \ + ../../source/components/disassembler/dmresrc.c \ + ../../source/components/disassembler/dmresrcl.c \ ++ ../../source/components/disassembler/dmresrcl2.c \ + ../../source/components/disassembler/dmresrcs.c \ + ../../source/components/disassembler/dmutils.c \ + ../../source/components/disassembler/dmwalk.c \ + ../../source/components/events/evevent.c \ ++ ../../source/components/events/evglock.c \ + ../../source/components/events/evgpeblk.c \ + ../../source/components/events/evgpe.c \ ++ ../../source/components/events/evgpeinit.c \ ++ ../../source/components/events/evgpeutil.c \ ++ ../../source/components/events/evhandler.c \ + ../../source/components/events/evmisc.c \ + ../../source/components/events/evregion.c \ + ../../source/components/events/evrgnini.c \ + ../../source/components/events/evsci.c \ + ../../source/components/events/evxface.c \ + ../../source/components/events/evxfevnt.c \ ++ ../../source/components/events/evxfgpe.c \ + ../../source/components/events/evxfregn.c \ + ../../source/components/hardware/hwacpi.c \ ++ ../../source/components/hardware/hwesleep.c \ + ../../source/components/hardware/hwgpe.c \ ++ ../../source/components/hardware/hwpci.c \ + ../../source/components/hardware/hwregs.c \ + ../../source/components/hardware/hwsleep.c \ ++ ../../source/components/hardware/hwxfsleep.c \ ++ ../../source/components/dispatcher/dsargs.c \ ++ ../../source/components/dispatcher/dscontrol.c \ + ../../source/components/dispatcher/dsfield.c \ + ../../source/components/dispatcher/dsinit.c \ + ../../source/components/dispatcher/dsmethod.c \ +@@ -60,11 +75,13 @@ + ../../source/components/dispatcher/dsutils.c \ + ../../source/components/dispatcher/dswexec.c \ + ../../source/components/dispatcher/dswload.c \ ++ ../../source/components/dispatcher/dswload2.c \ + ../../source/components/dispatcher/dswscope.c \ + ../../source/components/dispatcher/dswstate.c \ + ../../source/components/executer/exconfig.c \ + ../../source/components/executer/exconvrt.c \ + ../../source/components/executer/excreate.c \ ++ ../../source/components/executer/exdebug.c \ + ../../source/components/executer/exdump.c \ + ../../source/components/executer/exfield.c \ + ../../source/components/executer/exfldio.c \ +@@ -87,7 +104,9 @@ + ../../source/components/executer/exutils.c \ + ../../source/components/parser/psargs.c \ + ../../source/components/parser/psloop.c \ ++ ../../source/components/parser/psobject.c \ + ../../source/components/parser/psopcode.c \ ++ ../../source/components/parser/psopinfo.c \ + ../../source/components/parser/psparse.c \ + ../../source/components/parser/psscope.c \ + ../../source/components/parser/pstree.c \ +@@ -96,6 +115,8 @@ + ../../source/components/parser/psxface.c \ + ../../source/components/namespace/nsaccess.c \ + ../../source/components/namespace/nsalloc.c \ ++ ../../source/components/namespace/nsarguments.c \ ++ ../../source/components/namespace/nsconvert.c \ + ../../source/components/namespace/nsdump.c \ + ../../source/components/namespace/nsdumpdv.c \ + ../../source/components/namespace/nseval.c \ +@@ -105,6 +126,7 @@ + ../../source/components/namespace/nsobject.c \ + ../../source/components/namespace/nsparse.c \ + ../../source/components/namespace/nspredef.c \ ++ ../../source/components/namespace/nsprepkg.c \ + ../../source/components/namespace/nsrepair.c \ + ../../source/components/namespace/nsrepair2.c \ + ../../source/components/namespace/nssearch.c \ +@@ -117,26 +139,35 @@ + ../../source/components/resources/rscalc.c \ + ../../source/components/resources/rscreate.c \ + ../../source/components/resources/rsdump.c \ ++ ../../source/components/resources/rsdumpinfo.c \ ++ ../../source/components/resources/rsinfo.c \ + ../../source/components/resources/rsio.c \ + ../../source/components/resources/rsirq.c \ + ../../source/components/resources/rslist.c \ + ../../source/components/resources/rsmemory.c \ + ../../source/components/resources/rsmisc.c \ ++ ../../source/components/resources/rsserial.c \ + ../../source/components/resources/rsutils.c \ + ../../source/components/resources/rsxface.c \ +- ../../source/components/resources/rsinfo.c \ + ../../source/components/tables/tbfadt.c \ + ../../source/components/tables/tbfind.c \ + ../../source/components/tables/tbinstal.c \ ++ ../../source/components/tables/tbprint.c \ + ../../source/components/tables/tbutils.c \ + ../../source/components/tables/tbxface.c \ ++ ../../source/components/tables/tbxfload.c \ + ../../source/components/tables/tbxfroot.c \ ++ ../../source/components/utilities/utaddress.c \ + ../../source/components/utilities/utalloc.c \ ++ ../../source/components/utilities/utbuffer.c \ + ../../source/components/utilities/utcache.c \ + ../../source/components/utilities/utcopy.c \ + ../../source/components/utilities/utdebug.c \ ++ ../../source/components/utilities/utdecode.c \ + ../../source/components/utilities/utdelete.c \ ++ ../../source/components/utilities/uterror.c \ + ../../source/components/utilities/uteval.c \ ++ ../../source/components/utilities/utexcep.c \ + ../../source/components/utilities/utglobal.c \ + ../../source/components/utilities/utids.c \ + ../../source/components/utilities/utinit.c \ +@@ -145,17 +176,23 @@ + ../../source/components/utilities/utmisc.c \ + ../../source/components/utilities/utmutex.c \ + ../../source/components/utilities/utobject.c \ ++ ../../source/components/utilities/utosi.c \ ++ ../../source/components/utilities/utownerid.c \ ++ ../../source/components/utilities/utpredef.c \ + ../../source/components/utilities/utresrc.c \ + ../../source/components/utilities/utstate.c \ ++ ../../source/components/utilities/utstring.c \ + ../../source/components/utilities/uttrack.c \ +- ../../source/components/utilities/utxface.c ++ ../../source/components/utilities/utxface.c \ ++ ../../source/components/utilities/utxferror.c \ ++ ../../source/components/utilities/utxfinit.c + # ../../source/components/osunixxf.c + + + CFLAGS+= -Wall -g -D_LINUX -DNDEBUG -D_CONSOLE -DACPI_EXEC_APP -D_MULTI_THREADED -Wstrict-prototypes -I../../source/include + + +-acpiexec : $(patsubst %.c,%.o, $(SRCS)) ++$(PROG) : $(patsubst %.c,%.o, $(SRCS)) + $(CC) $(LDFLAGS) $(patsubst %.c,%.o, $(SRCS)) -o $(PROG) + + CLEANFILES= $(PROG) +diff -urN acpica-unix2-20130626/tests/aapits/osunixxf.c acpica-unix2-20130626-aapits/tests/aapits/osunixxf.c +--- acpica-unix2-20130626/tests/aapits/osunixxf.c 2013-01-17 12:48:29.000000000 -0700 ++++ acpica-unix2-20130626-aapits/tests/aapits/osunixxf.c 2013-07-25 15:11:08.225425856 -0600 +@@ -384,7 +384,6 @@ + const char *Fmt, + va_list Args) + { +- INT32 Count = 0; + UINT8 Flags; + + +@@ -397,7 +396,7 @@ + { + /* Output file is open, send the output there */ + +- Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args); ++ vfprintf (AcpiGbl_DebugFile, Fmt, Args); + } + else + { +@@ -409,7 +408,7 @@ + + if (Flags & ACPI_DB_CONSOLE_OUTPUT) + { +- Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args); ++ vfprintf (AcpiGbl_OutputFile, Fmt, Args); + } + + return; +@@ -1166,3 +1165,23 @@ + + return (AE_OK); + } ++ ++/****************************************************************************** ++ * ++ * FUNCTION: AcpiOsWaitEventsComplete ++ * ++ * PARAMETERS: None ++ * ++ * RETURN: None ++ * ++ * DESCRIPTION: Wait for all asynchronous events to complete. This ++ * implementation does nothing. ++ * ++ *****************************************************************************/ ++ ++void ++AcpiOsWaitEventsComplete ( ++ void) ++{ ++ return; ++} diff --git a/meta-linaro/recipes-extra/acpica/files/add-testing.patch b/meta-linaro/recipes-extra/acpica/files/add-testing.patch new file mode 100644 index 00000000..30447c8f --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/add-testing.patch @@ -0,0 +1,32 @@ +Index: acpica-unix/Makefile +=================================================================== +--- acpica-unix.orig/Makefile 2013-01-31 15:25:49.000000000 -0700 ++++ acpica-unix/Makefile 2013-01-31 15:25:49.000000000 -0700 +@@ -14,3 +14,27 @@ + + include generate/unix/Makefile.config + include generate/unix/Makefile.common ++ ++check: ++ cd tests ++ ++ # ASL tests ++ $(CURDIR)/tests/aslts.sh $(CURDIR)/tests/aslts $(CURDIR)/generate/unix ++ ++ # API Tests ++ $(CURDIR)/debian/run-aapits.sh $(CURDIR)/tests/aapits $(CURDIR)/generate/unix/bin ++ ++ # misc tests ++ $(CURDIR)/debian/run-misc-tests.sh $(CURDIR) 20130626 ++ ++ # Template tests ++ cd $(CURDIR)/tests/templates ++ make ++ if [ -f diff.log ] ; \ ++ then \ ++ if [ -s diff.log ] ; \ ++ then \ ++ exit 1 # implies errors occurred ; \ ++ fi ; \ ++ fi ++ diff --git a/meta-linaro/recipes-extra/acpica/files/debian-big_endian.patch b/meta-linaro/recipes-extra/acpica/files/debian-big_endian.patch new file mode 100644 index 00000000..a99a6c84 --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/debian-big_endian.patch @@ -0,0 +1,2490 @@ +Patch carried over from the prior iasl package and updated. This allows +for builds on big endian systems and cleans up endianness. Please see +http://lists.acpica.org/pipermail/devel/2010-July/000159.html. Resolves +BZ#865013 and BZ#856856. +-- + +Support compiling DSDT tables on big endian architectures. + +use the ACPI_MOVE_<N>_TO_<M> macros to swap the data written to the AML file on +big endian architectures (the macros themselves required a few fixes to work +correctly). +In some areas the use of temporary variables was necessary to be able to perform +sanity checks on the data before actually swapping the bytes. + +Signed-off-by: Mattia Dongili <malattia@linux.it> +Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> +--- + source/compiler/aslcodegen.c | 108 +++++++++++++++++------------- + source/compiler/aslopcodes.c | 4 +- + source/compiler/aslrestype1.c | 69 ++++++++++++++------ + source/compiler/aslrestype1i.c | 38 +++++++---- + source/compiler/aslrestype2.c | 25 ++++--- + source/compiler/aslrestype2d.c | 134 +++++++++++++++++++++----------------- + source/compiler/aslrestype2e.c | 117 +++++++++++++++++++++++---------- + source/compiler/aslrestype2q.c | 117 +++++++++++++++++++++------------ + source/compiler/aslrestype2s.c | 86 +++++++++++++++++------- + source/compiler/aslrestype2w.c | 127 +++++++++++++++++++++--------------- + source/include/acmacros.h | 15 +++-- + source/include/platform/aclinux.h | 7 +- + 12 file modificati, 541 inserzioni(+), 306 rimozioni(-) + +diff --git a/source/compiler/aslcodegen.c b/source/compiler/aslcodegen.c +index 2252ab4..c3c3e06 100644 +--- a/source/compiler/aslcodegen.c ++++ b/source/compiler/aslcodegen.c +@@ -238,16 +238,12 @@ CgWriteAmlOpcode ( + ACPI_PARSE_OBJECT *Op) + { + UINT8 PkgLenFirstByte; +- UINT32 i; +- union { +- UINT16 Opcode; +- UINT8 OpcodeBytes[2]; +- } Aml; +- union { +- UINT32 Len; +- UINT8 LenBytes[4]; +- } PkgLen; +- ++ UINT8 Byte; ++ UINT16 Word; ++ UINT32 DWord; ++ UINT64 QWord; ++ UINT16 AmlOpcode; ++ UINT32 PkgLen; + + /* We expect some DEFAULT_ARGs, just ignore them */ + +@@ -270,51 +266,52 @@ + + /* Special opcodes for within a field definition */ + +- Aml.Opcode = AML_FIELD_OFFSET_OP; ++ AmlOpcode = AML_FIELD_OFFSET_OP; + break; + + case AML_INT_ACCESSFIELD_OP: + +- Aml.Opcode = AML_FIELD_ACCESS_OP; ++ AmlOpcode = AML_FIELD_ACCESS_OP; + break; + + case AML_INT_CONNECTION_OP: + +- Aml.Opcode = AML_FIELD_CONNECTION_OP; ++ AmlOpcode = AML_FIELD_CONNECTION_OP; + break; + + default: + +- Aml.Opcode = Op->Asl.AmlOpcode; ++ AmlOpcode = Op->Asl.AmlOpcode; + break; + } + + +- switch (Aml.Opcode) ++ switch (AmlOpcode) + { + case AML_PACKAGE_LENGTH: + + /* Value is the length to be encoded (Used in field definitions) */ + +- PkgLen.Len = (UINT32) Op->Asl.Value.Integer; ++ PkgLen = (UINT32) Op->Asl.Value.Integer; + break; + + default: + + /* Check for two-byte opcode */ + +- if (Aml.Opcode > 0x00FF) ++ if (AmlOpcode > 0x00FF) + { + /* Write the high byte first */ +- +- CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1); ++ Byte = ACPI_HIBYTE(AmlOpcode); ++ CgLocalWriteAmlData (Op, &Byte, 1); + } + +- CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1); ++ Byte = ACPI_LOBYTE(AmlOpcode); ++ CgLocalWriteAmlData (Op, &Byte, 1); + + /* Subtreelength doesn't include length of package length bytes */ + +- PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes; ++ PkgLen = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes; + break; + } + +@@ -325,8 +321,8 @@ CgWriteAmlOpcode ( + if (Op->Asl.AmlPkgLenBytes == 1) + { + /* Simplest case -- no bytes to follow, just write the count */ +- +- CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1); ++ Byte = ACPI_LOBYTE(PkgLen); ++ CgLocalWriteAmlData (Op, &Byte, 1); + } + else if (Op->Asl.AmlPkgLenBytes != 0) + { +@@ -336,7 +332,7 @@ CgWriteAmlOpcode ( + */ + PkgLenFirstByte = (UINT8) + (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) | +- (PkgLen.LenBytes[0] & 0x0F)); ++ (PkgLen & 0x0F)); + + CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1); + +@@ -344,37 +340,44 @@ CgWriteAmlOpcode ( + * Shift the length over by the 4 bits we just stuffed + * in the first byte + */ +- PkgLen.Len >>= 4; ++ PkgLen >>= 4; + + /* Now we can write the remaining bytes - either 1, 2, or 3 bytes */ +- +- for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++) ++ Byte = ACPI_LOBYTE(PkgLen); ++ CgLocalWriteAmlData (Op, &Byte, 1); ++ if (Op->Asl.AmlPkgLenBytes >= 3) ++ { ++ Byte = ACPI_HIBYTE(PkgLen); ++ CgLocalWriteAmlData (Op, &Byte, 1); ++ } ++ if (Op->Asl.AmlPkgLenBytes >= 4) + { +- CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1); ++ Byte = ACPI_LOBYTE(ACPI_HIWORD(PkgLen)); ++ CgLocalWriteAmlData (Op, &Byte, 1); + } + } + } + +- switch (Aml.Opcode) ++ switch (AmlOpcode) + { + case AML_BYTE_OP: +- +- CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1); ++ Byte = (UINT8) Op->Asl.Value.Integer; ++ CgLocalWriteAmlData (Op, &Byte, 1); + break; + + case AML_WORD_OP: +- +- CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2); ++ ACPI_MOVE_64_TO_16(&Word, &Op->Asl.Value.Integer); ++ CgLocalWriteAmlData (Op, &Word, 2); + break; + + case AML_DWORD_OP: +- +- CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4); ++ ACPI_MOVE_64_TO_32(&DWord, &Op->Asl.Value.Integer); ++ CgLocalWriteAmlData (Op, &DWord, 4); + break; + + case AML_QWORD_OP: +- +- CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8); ++ ACPI_MOVE_64_TO_64(&QWord, &Op->Asl.Value.Integer); ++ CgLocalWriteAmlData (Op, &QWord, 8); + break; + + case AML_STRING_OP: +@@ -408,6 +409,7 @@ CgWriteTableHeader ( + ACPI_PARSE_OBJECT *Op) + { + ACPI_PARSE_OBJECT *Child; ++ UINT32 DWord; + + + /* AML filename */ +@@ -444,7 +446,7 @@ CgWriteTableHeader ( + /* OEM Revision */ + + Child = Child->Asl.Next; +- TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer; ++ ACPI_MOVE_64_TO_32(&TableHeader.OemRevision, &Child->Asl.Value.Integer); + + /* Compiler ID */ + +@@ -452,11 +453,12 @@ CgWriteTableHeader ( + + /* Compiler version */ + +- TableHeader.AslCompilerRevision = ASL_REVISION; ++ DWord = ASL_REVISION; ++ ACPI_MOVE_32_TO_32(&TableHeader.AslCompilerRevision, &DWord); + + /* Table length. Checksum zero for now, will rewrite later */ + +- TableHeader.Length = Gbl_TableLength; ++ ACPI_MOVE_32_TO_32(&TableHeader.Length, &Gbl_TableLength); + TableHeader.Checksum = 0; + + CgLocalWriteAmlData (Op, &TableHeader, sizeof (ACPI_TABLE_HEADER)); +@@ -520,7 +523,10 @@ CgWriteNode ( + ACPI_PARSE_OBJECT *Op) + { + ASL_RESOURCE_NODE *Rnode; +- ++ UINT8 Byte; ++ UINT16 Word; ++ UINT32 DWord; ++ UINT64 QWord; + + /* Always check for DEFAULT_ARG and other "Noop" nodes */ + /* TBD: this may not be the best place for this check */ +@@ -538,13 +544,24 @@ CgWriteNode ( + switch (Op->Asl.AmlOpcode) + { + case AML_RAW_DATA_BYTE: ++ Byte = (UINT8) Op->Asl.Value.Integer; ++ CgLocalWriteAmlData (Op, &Byte, 1); ++ return; ++ + case AML_RAW_DATA_WORD: +- case AML_RAW_DATA_DWORD: +- case AML_RAW_DATA_QWORD: ++ ACPI_MOVE_64_TO_16(&Word, &Op->Asl.Value.Integer); ++ CgLocalWriteAmlData (Op, &Word, 2); ++ return; + +- CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength); ++ case AML_RAW_DATA_DWORD: ++ ACPI_MOVE_64_TO_32(&DWord, &Op->Asl.Value.Integer); ++ CgLocalWriteAmlData (Op, &DWord, 4); + return; + ++ case AML_RAW_DATA_QWORD: ++ ACPI_MOVE_64_TO_64(&QWord, &Op->Asl.Value.Integer); ++ CgLocalWriteAmlData (Op, &QWord, 8); ++ return; + + case AML_RAW_DATA_BUFFER: + +diff --git a/source/compiler/aslopcodes.c b/source/compiler/aslopcodes.c +index cddc945..6deddc9 100644 +--- a/source/compiler/aslopcodes.c ++++ b/source/compiler/aslopcodes.c +@@ -476,6 +475,7 @@ OpcDoUnicode ( + UINT32 i; + UINT8 *AsciiString; + UINT16 *UnicodeString; ++ UINT16 UChar; + ACPI_PARSE_OBJECT *BufferLengthOp; + + +@@ -502,7 +502,8 @@ OpcDoUnicode ( + + for (i = 0; i < Count; i++) + { +- UnicodeString[i] = (UINT16) AsciiString[i]; ++ UChar = (UINT16) AsciiString[i]; ++ ACPI_MOVE_16_TO_16(&UnicodeString[i], &UChar); + } + + /* +diff --git a/source/compiler/aslrestype1.c b/source/compiler/aslrestype1.c +index 5b92151..b1fa5f5 100644 +--- a/source/compiler/aslrestype1.c ++++ b/source/compiler/aslrestype1.c +@@ -152,6 +152,11 @@ RsDoMemory24Descriptor ( + ACPI_PARSE_OBJECT *MaxOp = NULL; + ACPI_PARSE_OBJECT *LengthOp = NULL; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 Minimum = 0; ++ UINT16 Maximum = 0; ++ UINT16 AddressLength = 0; ++ UINT16 Alignment = 0; ++ UINT16 ResourceLength; + UINT32 i; + + +@@ -160,7 +165,8 @@ RsDoMemory24Descriptor ( + + Descriptor = Rnode->Buffer; + Descriptor->Memory24.DescriptorType = ACPI_RESOURCE_NAME_MEMORY24; +- Descriptor->Memory24.ResourceLength = 9; ++ ResourceLength = 9; ++ ACPI_MOVE_16_TO_16(&Descriptor->Memory24.ResourceLength, &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -177,7 +183,7 @@ RsDoMemory24Descriptor ( + + case 1: /* Min Address */ + +- Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum)); + MinOp = InitializerOp; +@@ -185,7 +191,7 @@ RsDoMemory24Descriptor ( + + case 2: /* Max Address */ + +- Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum)); + MaxOp = InitializerOp; +@@ -193,14 +199,14 @@ RsDoMemory24Descriptor ( + + case 3: /* Alignment */ + +- Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer; ++ Alignment = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_ALIGNMENT, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment)); + break; + + case 4: /* Length */ + +- Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength)); + LengthOp = InitializerOp; +@@ -223,12 +229,17 @@ RsDoMemory24Descriptor ( + /* Validate the Min/Max/Len/Align values (Alignment==0 means 64K) */ + + RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY24, +- Descriptor->Memory24.Minimum, +- Descriptor->Memory24.Maximum, +- Descriptor->Memory24.AddressLength, +- Descriptor->Memory24.Alignment, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Alignment, + MinOp, MaxOp, LengthOp, NULL, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Memory24.Minimum, &Minimum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Memory24.Maximum, &Maximum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Memory24.AddressLength, &AddressLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Memory24.Alignment, &Alignment); ++ + return (Rnode); + } + +@@ -259,6 +270,11 @@ RsDoMemory32Descriptor ( + ACPI_PARSE_OBJECT *LengthOp = NULL; + ACPI_PARSE_OBJECT *AlignOp = NULL; + ASL_RESOURCE_NODE *Rnode; ++ UINT32 Minimum = 0; ++ UINT32 Maximum = 0; ++ UINT32 AddressLength = 0; ++ UINT32 Alignment = 0; ++ UINT16 ResourceLength; + UINT32 i; + + +@@ -267,7 +283,8 @@ RsDoMemory32Descriptor ( + + Descriptor = Rnode->Buffer; + Descriptor->Memory32.DescriptorType = ACPI_RESOURCE_NAME_MEMORY32; +- Descriptor->Memory32.ResourceLength = 17; ++ ResourceLength = 17; ++ ACPI_MOVE_16_TO_16(&Descriptor->Memory32.ResourceLength, &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -284,7 +301,7 @@ RsDoMemory32Descriptor ( + + case 1: /* Min Address */ + +- Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum)); + MinOp = InitializerOp; +@@ -292,7 +309,7 @@ RsDoMemory32Descriptor ( + + case 2: /* Max Address */ + +- Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum)); + MaxOp = InitializerOp; +@@ -300,7 +317,7 @@ RsDoMemory32Descriptor ( + + case 3: /* Alignment */ + +- Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer; ++ Alignment = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_ALIGNMENT, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment)); + AlignOp = InitializerOp; +@@ -308,7 +325,7 @@ RsDoMemory32Descriptor ( + + case 4: /* Length */ + +- Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength)); + LengthOp = InitializerOp; +@@ -331,12 +348,17 @@ RsDoMemory32Descriptor ( + /* Validate the Min/Max/Len/Align values */ + + RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY32, +- Descriptor->Memory32.Minimum, +- Descriptor->Memory32.Maximum, +- Descriptor->Memory32.AddressLength, +- Descriptor->Memory32.Alignment, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Alignment, + MinOp, MaxOp, LengthOp, AlignOp, Op); + ++ ACPI_MOVE_32_TO_32(&Descriptor->Memory32.Minimum, &Minimum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Memory32.Maximum, &Maximum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Memory32.AddressLength, &AddressLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Memory32.Alignment, &Alignment); ++ + return (Rnode); + } + +@@ -363,6 +385,7 @@ RsDoMemory32FixedDescriptor ( + AML_RESOURCE *Descriptor; + ACPI_PARSE_OBJECT *InitializerOp; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 ResourceLength; + UINT32 i; + + +@@ -371,7 +394,8 @@ RsDoMemory32FixedDescriptor ( + + Descriptor = Rnode->Buffer; + Descriptor->FixedMemory32.DescriptorType = ACPI_RESOURCE_NAME_FIXED_MEMORY32; +- Descriptor->FixedMemory32.ResourceLength = 9; ++ ResourceLength = 9; ++ ACPI_MOVE_16_TO_16(&Descriptor->FixedMemory32.ResourceLength, &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -388,14 +412,16 @@ RsDoMemory32FixedDescriptor ( + + case 1: /* Address */ + +- Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer; ++ ACPI_MOVE_64_TO_32(&Descriptor->FixedMemory32.Address, ++ &InitializerOp->Asl.Value.Integer); + RsCreateDwordField (InitializerOp, ACPI_RESTAG_BASEADDRESS, + CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address)); + break; + + case 2: /* Length */ + +- Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; ++ ACPI_MOVE_64_TO_32(&Descriptor->FixedMemory32.AddressLength, ++ &InitializerOp->Asl.Value.Integer); + RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength)); + break; +diff --git a/source/compiler/aslrestype1i.c b/source/compiler/aslrestype1i.c +index 8335e8f..097eb05 100644 +--- a/source/compiler/aslrestype1i.c ++++ b/source/compiler/aslrestype1i.c +@@ -202,6 +202,8 @@ RsDoFixedDmaDescriptor ( + AML_RESOURCE *Descriptor; + ACPI_PARSE_OBJECT *InitializerOp; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 RequestLines = 0; ++ UINT16 Channels = 0; + UINT32 i; + + +@@ -220,14 +222,14 @@ RsDoFixedDmaDescriptor ( + { + case 0: /* DMA Request Lines [WORD] (_DMA) */ + +- Descriptor->FixedDma.RequestLines = (UINT16) InitializerOp->Asl.Value.Integer; ++ RequestLines = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_DMA, + CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.RequestLines)); + break; + + case 1: /* DMA Channel [WORD] (_TYP) */ + +- Descriptor->FixedDma.Channels = (UINT16) InitializerOp->Asl.Value.Integer; ++ Channels = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_DMATYPE, + CurrentByteOffset + ASL_RESDESC_OFFSET (FixedDma.Channels)); + break; +@@ -252,6 +253,9 @@ RsDoFixedDmaDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + ++ ACPI_MOVE_16_TO_16(&Descriptor->FixedDma.RequestLines, &RequestLines); ++ ACPI_MOVE_16_TO_16(&Descriptor->FixedDma.Channels, &Channels); ++ + return (Rnode); + } + +@@ -279,6 +283,7 @@ RsDoFixedIoDescriptor ( + ACPI_PARSE_OBJECT *InitializerOp; + ACPI_PARSE_OBJECT *AddressOp = NULL; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 Address = 0; + UINT32 i; + + +@@ -297,8 +302,7 @@ RsDoFixedIoDescriptor ( + { + case 0: /* Base Address */ + +- Descriptor->FixedIo.Address = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Address = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_BASEADDRESS, + CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address)); + AddressOp = InitializerOp; +@@ -328,11 +332,13 @@ RsDoFixedIoDescriptor ( + + /* Error checks */ + +- if (Descriptor->FixedIo.Address > 0x03FF) ++ if (Address > 0x03FF) + { + AslError (ASL_WARNING, ASL_MSG_ISA_ADDRESS, AddressOp, NULL); + } + ++ ACPI_MOVE_16_TO_16(&Descriptor->FixedIo.Address, &Address); ++ + return (Rnode); + } + +@@ -363,6 +369,8 @@ RsDoIoDescriptor ( + ACPI_PARSE_OBJECT *LengthOp = NULL; + ACPI_PARSE_OBJECT *AlignOp = NULL; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 Minimum = 0; ++ UINT16 Maximum = 0; + UINT32 i; + + +@@ -388,8 +396,7 @@ RsDoIoDescriptor ( + + case 1: /* Min Address */ + +- Descriptor->Io.Minimum = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum)); + MinOp = InitializerOp; +@@ -397,8 +404,7 @@ RsDoIoDescriptor ( + + case 2: /* Max Address */ + +- Descriptor->Io.Maximum = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum)); + MaxOp = InitializerOp; +@@ -439,12 +445,15 @@ RsDoIoDescriptor ( + /* Validate the Min/Max/Len/Align values */ + + RsSmallAddressCheck (ACPI_RESOURCE_NAME_IO, +- Descriptor->Io.Minimum, +- Descriptor->Io.Maximum, ++ Minimum, ++ Maximum, + Descriptor->Io.AddressLength, + Descriptor->Io.Alignment, + MinOp, MaxOp, LengthOp, AlignOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Io.Minimum, &Minimum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Io.Maximum, &Maximum); ++ + return (Rnode); + } + +@@ -565,9 +574,9 @@ RsDoIrqDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + +- /* Now we can set the channel mask */ ++ /* Now we can set the interrupt mask */ + +- Descriptor->Irq.IrqMask = IrqMask; ++ ACPI_MOVE_16_TO_16(&Descriptor->Irq.IrqMask, &IrqMask); + return (Rnode); + } + +@@ -667,6 +676,6 @@ RsDoIrqNoFlagsDescriptor ( + + /* Now we can set the interrupt mask */ + +- Descriptor->Irq.IrqMask = IrqMask; ++ ACPI_MOVE_16_TO_16(&Descriptor->Irq.IrqMask, &IrqMask); + return (Rnode); + } +diff --git a/source/compiler/aslrestype2.c b/source/compiler/aslrestype2.c +index f0de854..b6d8d1d 100644 +--- a/source/compiler/aslrestype2.c ++++ b/source/compiler/aslrestype2.c +@@ -79,6 +79,7 @@ RsDoGeneralRegisterDescriptor ( + AML_RESOURCE *Descriptor; + ACPI_PARSE_OBJECT *InitializerOp; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 ResourceLength; + UINT32 i; + + +@@ -87,7 +88,9 @@ RsDoGeneralRegisterDescriptor ( + + Descriptor = Rnode->Buffer; + Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER; +- Descriptor->GenericReg.ResourceLength = 12; ++ ResourceLength = 12; ++ ACPI_MOVE_16_TO_16(&Descriptor->GenericReg.ResourceLength, ++ &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -118,7 +121,8 @@ RsDoGeneralRegisterDescriptor ( + + case 3: /* Register Address */ + +- Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer; ++ ACPI_MOVE_64_TO_64(&Descriptor->GenericReg.Address, ++ &InitializerOp->Asl.Value.Integer); + RsCreateQwordField (InitializerOp, ACPI_RESTAG_ADDRESS, + CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address)); + break; +@@ -176,6 +180,7 @@ RsDoInterruptDescriptor ( + AML_RESOURCE *Rover = NULL; + ACPI_PARSE_OBJECT *InitializerOp; + ASL_RESOURCE_NODE *Rnode; ++ UINT16 ResourceLength = 0; + UINT16 StringLength = 0; + UINT32 OptionIndex = 0; + UINT32 i; +@@ -222,7 +227,7 @@ RsDoInterruptDescriptor ( + * Initial descriptor length -- may be enlarged if there are + * optional fields present + */ +- Descriptor->ExtendedIrq.ResourceLength = 2; /* Flags and table length byte */ ++ ResourceLength = 2; /* Flags and table length byte */ + Descriptor->ExtendedIrq.InterruptCount = 0; + + Rover = ACPI_CAST_PTR (AML_RESOURCE, +@@ -330,10 +335,11 @@ RsDoInterruptDescriptor ( + + /* Save the integer and move pointer to the next one */ + +- Rover->DwordItem = (UINT32) InitializerOp->Asl.Value.Integer; ++ ACPI_MOVE_64_TO_32(&Rover->DwordItem, ++ &InitializerOp->Asl.Value.Integer); + Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->DwordItem), 4); + Descriptor->ExtendedIrq.InterruptCount++; +- Descriptor->ExtendedIrq.ResourceLength += 4; ++ ResourceLength += 4; + + /* Case 7: First interrupt number in list */ + +@@ -369,7 +376,7 @@ RsDoInterruptDescriptor ( + { + Rover->ByteItem = ResSourceIndex; + Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->ByteItem), 1); +- Descriptor->ExtendedIrq.ResourceLength += 1; ++ ResourceLength += 1; + } + + /* Add optional ResSource string if present */ +@@ -381,13 +387,14 @@ RsDoInterruptDescriptor ( + Rover = ACPI_ADD_PTR ( + AML_RESOURCE, &(Rover->ByteItem), StringLength); + +- Descriptor->ExtendedIrq.ResourceLength = (UINT16) +- (Descriptor->ExtendedIrq.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + } + + Rnode->BufferLength = (ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]) - + ASL_RESDESC_OFFSET (ExtendedIrq.DescriptorType)) + + OptionIndex + StringLength; ++ ACPI_MOVE_16_TO_16(&Descriptor->ExtendedIrq.ResourceLength, ++ &ResourceLength); + return (Rnode); + } + +@@ -438,7 +445,7 @@ RsDoVendorLargeDescriptor ( + + Descriptor = Rnode->Buffer; + Descriptor->VendorLarge.DescriptorType = ACPI_RESOURCE_NAME_VENDOR_LARGE; +- Descriptor->VendorLarge.ResourceLength = (UINT16) i; ++ ACPI_MOVE_32_TO_16(&Descriptor->VendorLarge.ResourceLength, &i); + + /* Point to end-of-descriptor for vendor data */ + +diff --git a/source/compiler/aslrestype2d.c b/source/compiler/aslrestype2d.c +index 1ca0f2d..5bebd30 100644 +--- a/source/compiler/aslrestype2d.c ++++ b/source/compiler/aslrestype2d.c +@@ -83,7 +83,13 @@ RsDoDwordIoDescriptor ( + ACPI_PARSE_OBJECT *GranOp = NULL; + ASL_RESOURCE_NODE *Rnode; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; + UINT32 OptionIndex = 0; ++ UINT32 Minimum = 0; ++ UINT32 Maximum = 0; ++ UINT32 AddressLength = 0; ++ UINT32 Granularity = 0; ++ UINT32 TranslationOffset = 0; + UINT8 *OptionalFields; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; +@@ -104,8 +110,7 @@ RsDoDwordIoDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); +- Descriptor->Address32.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS32) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS32) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -149,8 +154,7 @@ RsDoDwordIoDescriptor ( + + case 5: /* Address Granularity */ + +- Descriptor->Address32.Granularity = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Granularity = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); + GranOp = InitializerOp; +@@ -158,8 +162,7 @@ RsDoDwordIoDescriptor ( + + case 6: /* Address Min */ + +- Descriptor->Address32.Minimum = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); + MinOp = InitializerOp; +@@ -167,8 +170,7 @@ RsDoDwordIoDescriptor ( + + case 7: /* Address Max */ + +- Descriptor->Address32.Maximum = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); + MaxOp = InitializerOp; +@@ -176,16 +178,14 @@ RsDoDwordIoDescriptor ( + + case 8: /* Translation Offset */ + +- Descriptor->Address32.TranslationOffset = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); + break; + + case 9: /* Address Length */ + +- Descriptor->Address32.AddressLength = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); + LengthOp = InitializerOp; +@@ -199,7 +199,7 @@ RsDoDwordIoDescriptor ( + + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address32.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -213,8 +213,7 @@ RsDoDwordIoDescriptor ( + { + /* Found a valid ResourceSource */ + +- Descriptor->Address32.ResourceLength = (UINT16) +- (Descriptor->Address32.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -274,13 +273,20 @@ RsDoDwordIoDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- (UINT64) Descriptor->Address32.Minimum, +- (UINT64) Descriptor->Address32.Maximum, +- (UINT64) Descriptor->Address32.AddressLength, +- (UINT64) Descriptor->Address32.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address32.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address32.ResourceLength, &ResourceLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Minimum, &Minimum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Maximum, &Maximum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.AddressLength, &AddressLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Granularity, &Granularity); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + + OptionIndex + StringLength; + return (Rnode); +@@ -315,7 +321,13 @@ RsDoDwordMemoryDescriptor ( + ASL_RESOURCE_NODE *Rnode; + UINT8 *OptionalFields; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; + UINT32 OptionIndex = 0; ++ UINT32 Minimum = 0; ++ UINT32 Maximum = 0; ++ UINT32 AddressLength = 0; ++ UINT32 Granularity = 0; ++ UINT32 TranslationOffset = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -335,11 +347,9 @@ RsDoDwordMemoryDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); +- Descriptor->Address32.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS32) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS32) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + +- + /* Process all child initialization nodes */ + + for (i = 0; InitializerOp; i++) +@@ -388,8 +398,7 @@ RsDoDwordMemoryDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->Address32.Granularity = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Granularity = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); + GranOp = InitializerOp; +@@ -397,8 +406,7 @@ RsDoDwordMemoryDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->Address32.Minimum = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); + MinOp = InitializerOp; +@@ -406,8 +414,7 @@ RsDoDwordMemoryDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->Address32.Maximum = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); + MaxOp = InitializerOp; +@@ -415,16 +422,14 @@ RsDoDwordMemoryDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->Address32.TranslationOffset = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->Address32.AddressLength = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); + LengthOp = InitializerOp; +@@ -436,7 +441,7 @@ RsDoDwordMemoryDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address32.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -448,8 +453,8 @@ RsDoDwordMemoryDescriptor ( + { + if (StringLength) + { +- Descriptor->Address32.ResourceLength = (UINT16) +- (Descriptor->Address32.ResourceLength + StringLength); ++ ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -510,13 +515,20 @@ RsDoDwordMemoryDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- (UINT64) Descriptor->Address32.Minimum, +- (UINT64) Descriptor->Address32.Maximum, +- (UINT64) Descriptor->Address32.AddressLength, +- (UINT64) Descriptor->Address32.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address32.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address32.ResourceLength, &ResourceLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Minimum, &Minimum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Maximum, &Maximum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.AddressLength, &AddressLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Granularity, &Granularity); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + + OptionIndex + StringLength; + return (Rnode); +@@ -551,7 +563,13 @@ RsDoDwordSpaceDescriptor ( + ASL_RESOURCE_NODE *Rnode; + UINT8 *OptionalFields; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; + UINT32 OptionIndex = 0; ++ UINT32 Minimum = 0; ++ UINT32 Maximum = 0; ++ UINT32 AddressLength = 0; ++ UINT32 Granularity = 0; ++ UINT32 TranslationOffset = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -570,8 +588,7 @@ RsDoDwordSpaceDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); +- Descriptor->Address32.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS32) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS32) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -620,8 +637,7 @@ RsDoDwordSpaceDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->Address32.Granularity = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Granularity = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); + GranOp = InitializerOp; +@@ -629,8 +645,7 @@ RsDoDwordSpaceDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->Address32.Minimum = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); + MinOp = InitializerOp; +@@ -638,8 +651,7 @@ RsDoDwordSpaceDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->Address32.Maximum = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); + MaxOp = InitializerOp; +@@ -647,16 +661,14 @@ RsDoDwordSpaceDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->Address32.TranslationOffset = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->Address32.AddressLength = +- (UINT32) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); + LengthOp = InitializerOp; +@@ -668,7 +680,7 @@ RsDoDwordSpaceDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address32.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -680,8 +692,7 @@ RsDoDwordSpaceDescriptor ( + { + if (StringLength) + { +- Descriptor->Address32.ResourceLength = (UINT16) +- (Descriptor->Address32.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -728,13 +739,20 @@ RsDoDwordSpaceDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- (UINT64) Descriptor->Address32.Minimum, +- (UINT64) Descriptor->Address32.Maximum, +- (UINT64) Descriptor->Address32.AddressLength, +- (UINT64) Descriptor->Address32.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address32.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address32.ResourceLength, &ResourceLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Minimum, &Minimum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Maximum, &Maximum); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.AddressLength, &AddressLength); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.Granularity, &Granularity); ++ ACPI_MOVE_32_TO_32(&Descriptor->Address32.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + + OptionIndex + StringLength; + return (Rnode); +diff --git a/source/compiler/aslrestype2e.c b/source/compiler/aslrestype2e.c +index e5fff47..d701880 100644 +--- a/source/compiler/aslrestype2e.c ++++ b/source/compiler/aslrestype2e.c +@@ -82,6 +82,13 @@ RsDoExtendedIoDescriptor ( + ACPI_PARSE_OBJECT *GranOp = NULL; + ASL_RESOURCE_NODE *Rnode; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; ++ UINT64 Minimum = 0; ++ UINT64 Maximum = 0; ++ UINT64 AddressLength = 0; ++ UINT64 Granularity = 0; ++ UINT64 TranslationOffset = 0; ++ UINT64 TypeSpecific = 0; + UINT32 i; + + +@@ -96,9 +103,10 @@ RsDoExtendedIoDescriptor ( + Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; + Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; + +- Descriptor->ExtAddress64.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - + sizeof (AML_RESOURCE_LARGE_HEADER)); ++ ACPI_MOVE_16_TO_16(&Descriptor->ExtAddress64.ResourceLength, ++ &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -141,7 +149,7 @@ RsDoExtendedIoDescriptor ( + + case 5: /* Address Granularity */ + +- Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; ++ Granularity = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); + GranOp = InitializerOp; +@@ -149,7 +157,7 @@ RsDoExtendedIoDescriptor ( + + case 6: /* Address Min */ + +- Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; ++ Minimum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); + MinOp = InitializerOp; +@@ -157,7 +165,7 @@ RsDoExtendedIoDescriptor ( + + case 7: /* Address Max */ + +- Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; ++ Maximum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); + MaxOp = InitializerOp; +@@ -165,14 +173,14 @@ RsDoExtendedIoDescriptor ( + + case 8: /* Translation Offset */ + +- Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; ++ TranslationOffset = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); + break; + + case 9: /* Address Length */ + +- Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; ++ AddressLength = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); + LengthOp = InitializerOp; +@@ -180,7 +188,7 @@ RsDoExtendedIoDescriptor ( + + case 10: /* Type-Specific Attributes */ + +- Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; ++ TypeSpecific = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); + break; +@@ -216,13 +224,20 @@ RsDoExtendedIoDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- Descriptor->ExtAddress64.Minimum, +- Descriptor->ExtAddress64.Maximum, +- Descriptor->ExtAddress64.AddressLength, +- Descriptor->ExtAddress64.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->ExtAddress64.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Minimum, &Minimum); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Maximum, &Maximum); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.AddressLength, &AddressLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Granularity, &Granularity); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.TranslationOffset, &TranslationOffset); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.TypeSpecific, &TypeSpecific); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; + return (Rnode); + } +@@ -255,6 +270,13 @@ RsDoExtendedMemoryDescriptor ( + ACPI_PARSE_OBJECT *GranOp = NULL; + ASL_RESOURCE_NODE *Rnode; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; ++ UINT64 Minimum = 0; ++ UINT64 Maximum = 0; ++ UINT64 AddressLength = 0; ++ UINT64 Granularity = 0; ++ UINT64 TranslationOffset = 0; ++ UINT64 TypeSpecific = 0; + UINT32 i; + + +@@ -269,9 +291,10 @@ RsDoExtendedMemoryDescriptor ( + Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; + Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; + +- Descriptor->ExtAddress64.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - + sizeof (AML_RESOURCE_LARGE_HEADER)); ++ ACPI_MOVE_16_TO_16(&Descriptor->ExtAddress64.ResourceLength, ++ &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -321,7 +344,7 @@ RsDoExtendedMemoryDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; ++ Granularity = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); + GranOp = InitializerOp; +@@ -329,7 +352,7 @@ RsDoExtendedMemoryDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; ++ Minimum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); + MinOp = InitializerOp; +@@ -337,7 +360,7 @@ RsDoExtendedMemoryDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; ++ Maximum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); + MaxOp = InitializerOp; +@@ -345,14 +368,14 @@ RsDoExtendedMemoryDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; ++ TranslationOffset = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; ++ AddressLength = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); + LengthOp = InitializerOp; +@@ -360,7 +383,7 @@ RsDoExtendedMemoryDescriptor ( + + case 11: /* Type-Specific Attributes */ + +- Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; ++ TypeSpecific = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); + break; +@@ -397,13 +420,20 @@ RsDoExtendedMemoryDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- Descriptor->ExtAddress64.Minimum, +- Descriptor->ExtAddress64.Maximum, +- Descriptor->ExtAddress64.AddressLength, +- Descriptor->ExtAddress64.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->ExtAddress64.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Minimum, &Minimum); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Maximum, &Maximum); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.AddressLength, &AddressLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Granularity, &Granularity); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.TranslationOffset, &TranslationOffset); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.TypeSpecific, &TypeSpecific); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; + return (Rnode); + } +@@ -436,6 +466,13 @@ RsDoExtendedSpaceDescriptor ( + ACPI_PARSE_OBJECT *GranOp = NULL; + ASL_RESOURCE_NODE *Rnode; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; ++ UINT64 Minimum = 0; ++ UINT64 Maximum = 0; ++ UINT64 AddressLength = 0; ++ UINT64 Granularity = 0; ++ UINT64 TranslationOffset = 0; ++ UINT64 TypeSpecific = 0; + UINT32 i; + + +@@ -449,9 +486,10 @@ RsDoExtendedSpaceDescriptor ( + Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; + Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; + +- Descriptor->ExtAddress64.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - + sizeof (AML_RESOURCE_LARGE_HEADER)); ++ ACPI_MOVE_16_TO_16(&Descriptor->ExtAddress64.ResourceLength, ++ &ResourceLength); + + /* Process all child initialization nodes */ + +@@ -499,7 +537,7 @@ RsDoExtendedSpaceDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; ++ Granularity = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); + GranOp = InitializerOp; +@@ -507,7 +545,7 @@ RsDoExtendedSpaceDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; ++ Minimum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); + MinOp = InitializerOp; +@@ -515,7 +553,7 @@ RsDoExtendedSpaceDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; ++ Maximum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); + MaxOp = InitializerOp; +@@ -523,14 +561,14 @@ RsDoExtendedSpaceDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; ++ TranslationOffset = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; ++ AddressLength = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); + LengthOp = InitializerOp; +@@ -538,7 +576,7 @@ RsDoExtendedSpaceDescriptor ( + + case 11: /* Type-Specific Attributes */ + +- Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; ++ TypeSpecific = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, + CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); + break; +@@ -560,13 +598,20 @@ RsDoExtendedSpaceDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- Descriptor->ExtAddress64.Minimum, +- Descriptor->ExtAddress64.Maximum, +- Descriptor->ExtAddress64.AddressLength, +- Descriptor->ExtAddress64.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->ExtAddress64.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Minimum, &Minimum); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Maximum, &Maximum); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.AddressLength, &AddressLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.Granularity, &Granularity); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.TranslationOffset, &TranslationOffset); ++ ACPI_MOVE_64_TO_64(&Descriptor->ExtAddress64.TypeSpecific, &TypeSpecific); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; + return (Rnode); + } +diff --git a/source/compiler/aslrestype2q.c b/source/compiler/aslrestype2q.c +index 65c242a..c92d545 100644 +--- a/source/compiler/aslrestype2q.c ++++ b/source/compiler/aslrestype2q.c +@@ -84,7 +84,13 @@ RsDoQwordIoDescriptor ( + ASL_RESOURCE_NODE *Rnode; + UINT8 *OptionalFields; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; + UINT32 OptionIndex = 0; ++ UINT64 Minimum = 0; ++ UINT64 Maximum = 0; ++ UINT64 AddressLength = 0; ++ UINT64 Granularity = 0; ++ UINT64 TranslationOffset = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -104,8 +110,7 @@ RsDoQwordIoDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64); +- Descriptor->Address64.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS64) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS64) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -149,7 +154,7 @@ RsDoQwordIoDescriptor ( + + case 5: /* Address Granularity */ + +- Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer; ++ Granularity = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity)); + GranOp = InitializerOp; +@@ -157,7 +162,7 @@ RsDoQwordIoDescriptor ( + + case 6: /* Address Min */ + +- Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer; ++ Minimum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum)); + MinOp = InitializerOp; +@@ -165,7 +170,7 @@ RsDoQwordIoDescriptor ( + + case 7: /* Address Max */ + +- Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer; ++ Maximum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum)); + MaxOp = InitializerOp; +@@ -173,14 +178,14 @@ RsDoQwordIoDescriptor ( + + case 8: /* Translation Offset */ + +- Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer; ++ TranslationOffset = InitializerOp->Asl.Value.Integer; + RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset)); + break; + + case 9: /* Address Length */ + +- Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer; ++ AddressLength = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength)); + LengthOp = InitializerOp; +@@ -192,7 +197,7 @@ RsDoQwordIoDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address64.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -204,8 +209,7 @@ RsDoQwordIoDescriptor ( + { + if (StringLength) + { +- Descriptor->Address64.ResourceLength = (UINT16) +- (Descriptor->Address64.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -265,13 +269,20 @@ RsDoQwordIoDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- Descriptor->Address64.Minimum, +- Descriptor->Address64.Maximum, +- Descriptor->Address64.AddressLength, +- Descriptor->Address64.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address64.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address64.ResourceLength, &ResourceLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Minimum, &Minimum); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Maximum, &Maximum); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.AddressLength, &AddressLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Granularity, &Granularity); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) + + OptionIndex + StringLength; + return (Rnode); +@@ -306,7 +317,13 @@ RsDoQwordMemoryDescriptor ( + ASL_RESOURCE_NODE *Rnode; + UINT8 *OptionalFields; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; + UINT32 OptionIndex = 0; ++ UINT64 Minimum = 0; ++ UINT64 Maximum = 0; ++ UINT64 AddressLength = 0; ++ UINT64 Granularity = 0; ++ UINT64 TranslationOffset = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -326,8 +343,7 @@ RsDoQwordMemoryDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64); +- Descriptor->Address64.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS64) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS64) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -378,7 +394,7 @@ RsDoQwordMemoryDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer; ++ Granularity = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity)); + GranOp = InitializerOp; +@@ -386,7 +402,7 @@ RsDoQwordMemoryDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer; ++ Minimum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum)); + MinOp = InitializerOp; +@@ -394,7 +410,7 @@ RsDoQwordMemoryDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer; ++ Maximum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum)); + MaxOp = InitializerOp; +@@ -402,14 +418,14 @@ RsDoQwordMemoryDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer; ++ TranslationOffset = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer; ++ AddressLength = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength)); + LengthOp = InitializerOp; +@@ -421,7 +437,7 @@ RsDoQwordMemoryDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address64.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -433,8 +449,7 @@ RsDoQwordMemoryDescriptor ( + { + if (StringLength) + { +- Descriptor->Address64.ResourceLength = (UINT16) +- (Descriptor->Address64.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -495,13 +510,20 @@ RsDoQwordMemoryDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- Descriptor->Address64.Minimum, +- Descriptor->Address64.Maximum, +- Descriptor->Address64.AddressLength, +- Descriptor->Address64.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address64.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address64.ResourceLength, &ResourceLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Minimum, &Minimum); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Maximum, &Maximum); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.AddressLength, &AddressLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Granularity, &Granularity); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) + + OptionIndex + StringLength; + return (Rnode); +@@ -536,8 +558,14 @@ RsDoQwordSpaceDescriptor ( + ASL_RESOURCE_NODE *Rnode; + UINT8 *OptionalFields; + UINT16 StringLength = 0; ++ UINT16 ResourceLength = 0; + UINT32 OptionIndex = 0; + UINT32 i; ++ UINT64 Minimum = 0; ++ UINT64 Maximum = 0; ++ UINT64 AddressLength = 0; ++ UINT64 Granularity = 0; ++ UINT64 TranslationOffset = 0; + BOOLEAN ResSourceIndex = FALSE; + + +@@ -555,8 +583,7 @@ RsDoQwordSpaceDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64); +- Descriptor->Address64.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS64) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS64) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -605,7 +632,7 @@ RsDoQwordSpaceDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer; ++ Granularity = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity)); + GranOp = InitializerOp; +@@ -613,7 +640,7 @@ RsDoQwordSpaceDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer; ++ Minimum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum)); + MinOp = InitializerOp; +@@ -621,7 +648,7 @@ RsDoQwordSpaceDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer; ++ Maximum = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum)); + MaxOp = InitializerOp; +@@ -629,14 +656,14 @@ RsDoQwordSpaceDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer; ++ TranslationOffset = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer; ++ AddressLength = InitializerOp->Asl.Value.Integer; + RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength)); + LengthOp = InitializerOp; +@@ -648,7 +675,7 @@ RsDoQwordSpaceDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address64.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -660,8 +687,7 @@ RsDoQwordSpaceDescriptor ( + { + if (StringLength) + { +- Descriptor->Address64.ResourceLength = (UINT16) +- (Descriptor->Address64.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -707,13 +733,20 @@ RsDoQwordSpaceDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- Descriptor->Address64.Minimum, +- Descriptor->Address64.Maximum, +- Descriptor->Address64.AddressLength, +- Descriptor->Address64.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address64.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address64.ResourceLength, &ResourceLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Minimum, &Minimum); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Maximum, &Maximum); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.AddressLength, &AddressLength); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.Granularity, &Granularity); ++ ACPI_MOVE_64_TO_64(&Descriptor->Address64.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) + + OptionIndex + StringLength; + return (Rnode); +diff --git a/source/compiler/aslrestype2s.c b/source/compiler/aslrestype2s.c +index a9d24cd..4d9c7db 100644 +--- a/source/compiler/aslrestype2s.c ++++ b/source/compiler/aslrestype2s.c +@@ -293,6 +293,9 @@ RsDoGpioIntDescriptor ( + UINT16 VendorLength; + UINT16 InterruptLength; + UINT16 DescriptorSize; ++ UINT16 IntFlags = 0; ++ UINT16 DebounceTimeout = 0; ++ UINT16 Flags = 0; + UINT32 i; + + +@@ -348,21 +351,21 @@ RsDoGpioIntDescriptor ( + { + case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0); ++ RsSetFlagBits16 (&IntFlags, InitializerOp, 0, 0); + RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0); + break; + + case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0); ++ RsSetFlagBits16 (&IntFlags, InitializerOp, 1, 0); + RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2); + break; + + case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0); ++ RsSetFlagBits16 (&IntFlags, InitializerOp, 3, 0); + RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2); + break; +@@ -376,7 +379,7 @@ RsDoGpioIntDescriptor ( + + case 4: /* Debounce Timeout [WORD] (_DBT) */ + +- Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; ++ DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout)); + break; +@@ -402,7 +405,7 @@ RsDoGpioIntDescriptor ( + + case 7: /* Resource Usage (consumer/producer) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1); ++ RsSetFlagBits16 (&Flags, InitializerOp, 0, 1); + break; + + case 8: /* Resource Tag (Descriptor Name) */ +@@ -466,6 +469,10 @@ RsDoGpioIntDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.IntFlags, &IntFlags); ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.DebounceTimeout, &DebounceTimeout); ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.Flags, &Flags); ++ + return (Rnode); + } + +@@ -499,6 +506,10 @@ RsDoGpioIoDescriptor ( + UINT16 VendorLength; + UINT16 InterruptLength; + UINT16 DescriptorSize; ++ UINT16 IntFlags = 0; ++ UINT16 DebounceTimeout = 0; ++ UINT16 DriveStrength = 0; ++ UINT16 Flags = 0; + UINT32 i; + + +@@ -554,7 +565,7 @@ RsDoGpioIoDescriptor ( + { + case 0: /* Share Type [Flags] (_SHR) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0); ++ RsSetFlagBits16 (&IntFlags, InitializerOp, 3, 0); + RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3); + break; +@@ -568,21 +579,21 @@ RsDoGpioIoDescriptor ( + + case 2: /* Debounce Timeout [WORD] (_DBT) */ + +- Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; ++ DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout)); + break; + + case 3: /* Drive Strength [WORD] (_DRS) */ + +- Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer; ++ DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength)); + break; + + case 4: /* I/O Restriction [Flag] (_IOR) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0); ++ RsSetFlagBits16 (&IntFlags, InitializerOp, 0, 0); + RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2); + break; +@@ -608,7 +619,7 @@ RsDoGpioIoDescriptor ( + + case 7: /* Resource Usage (consumer/producer) */ + +- RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1); ++ RsSetFlagBits16 (&Flags, InitializerOp, 0, 1); + break; + + case 8: /* Resource Tag (Descriptor Name) */ +@@ -671,6 +683,11 @@ RsDoGpioIoDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.IntFlags, &IntFlags); ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.DebounceTimeout, &DebounceTimeout); ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.DriveStrength, &DriveStrength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Gpio.Flags, &Flags); ++ + return (Rnode); + } + +@@ -702,6 +719,9 @@ RsDoI2cSerialBusDescriptor ( + UINT16 ResSourceLength; + UINT16 VendorLength; + UINT16 DescriptorSize; ++ UINT16 SlaveAddress = 0; ++ UINT32 ConnectionSpeed = 0; ++ UINT16 TypeSpecificFlags = 0; + UINT32 i; + + +@@ -749,7 +769,7 @@ RsDoI2cSerialBusDescriptor ( + { + case 0: /* Slave Address [WORD] (_ADR) */ + +- Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer; ++ SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS, + CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress)); + break; +@@ -763,14 +783,14 @@ RsDoI2cSerialBusDescriptor ( + + case 2: /* Connection Speed [DWORD] (_SPE) */ + +- Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; ++ ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, + CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed)); + break; + + case 3: /* Addressing Mode [Flag] (_MOD) */ + +- RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 0, 0); + RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, + CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0); + break; +@@ -818,6 +837,9 @@ RsDoI2cSerialBusDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + ++ ACPI_MOVE_16_TO_16(&Descriptor->I2cSerialBus.SlaveAddress, &SlaveAddress); ++ ACPI_MOVE_32_TO_32(&Descriptor->I2cSerialBus.ConnectionSpeed, &ConnectionSpeed); ++ ACPI_MOVE_16_TO_16(&Descriptor->I2cSerialBus.TypeSpecificFlags, &TypeSpecificFlags); + return (Rnode); + } + +@@ -849,6 +871,9 @@ RsDoSpiSerialBusDescriptor ( + UINT16 ResSourceLength; + UINT16 VendorLength; + UINT16 DescriptorSize; ++ UINT16 DeviceSelection = 0; ++ UINT32 ConnectionSpeed = 0; ++ UINT16 TypeSpecificFlags = 0; + UINT32 i; + + +@@ -896,21 +921,21 @@ RsDoSpiSerialBusDescriptor ( + { + case 0: /* Device Selection [WORD] (_ADR) */ + +- Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer; ++ DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS, + CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection)); + break; + + case 1: /* Device Polarity [Flag] (_DPL) */ + +- RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 1, 0); + RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1); + break; + + case 2: /* Wire Mode [Flag] (_MOD) */ + +- RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 0, 0); + RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE, + CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0); + break; +@@ -931,7 +956,7 @@ RsDoSpiSerialBusDescriptor ( + + case 5: /* Connection Speed [DWORD] (_SPE) */ + +- Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; ++ ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, + CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed)); + break; +@@ -993,6 +1017,10 @@ RsDoSpiSerialBusDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + ++ ACPI_MOVE_16_TO_16(&Descriptor->SpiSerialBus.DeviceSelection, &DeviceSelection); ++ ACPI_MOVE_32_TO_32(&Descriptor->SpiSerialBus.ConnectionSpeed, &ConnectionSpeed); ++ ACPI_MOVE_16_TO_16(&Descriptor->SpiSerialBus.TypeSpecificFlags, &TypeSpecificFlags); ++ + return (Rnode); + } + +@@ -1024,6 +1052,10 @@ RsDoUartSerialBusDescriptor ( + UINT16 ResSourceLength; + UINT16 VendorLength; + UINT16 DescriptorSize; ++ UINT32 DefaultBaudRate = 0; ++ UINT16 TypeSpecificFlags = 0; ++ UINT16 RxFifoSize = 0; ++ UINT16 TxFifoSize = 0; + UINT32 i; + + +@@ -1071,21 +1103,21 @@ RsDoUartSerialBusDescriptor ( + { + case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */ + +- Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer; ++ DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer; + RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate)); + break; + + case 1: /* Bits Per Byte [Flags] (_LEN) */ + +- RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 4, 3); + RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3); + break; + + case 2: /* Stop Bits [Flags] (_STB) */ + +- RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 2, 1); + RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2); + break; +@@ -1099,7 +1131,7 @@ RsDoUartSerialBusDescriptor ( + + case 4: /* Endianness [Flag] (_END) */ + +- RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 7, 0); + RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7); + break; +@@ -1113,21 +1145,21 @@ RsDoUartSerialBusDescriptor ( + + case 6: /* Flow Control [Flags] (_FLC) */ + +- RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0); ++ RsSetFlagBits16 (&TypeSpecificFlags, InitializerOp, 0, 0); + RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2); + break; + + case 7: /* Rx Buffer Size [WORD] (_RXL) */ + +- Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; ++ RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize)); + break; + + case 8: /* Tx Buffer Size [WORD] (_TXL) */ + +- Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; ++ TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX, + CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize)); + break; +@@ -1185,5 +1216,10 @@ RsDoUartSerialBusDescriptor ( + InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); + } + ++ ACPI_MOVE_32_TO_32(&Descriptor->UartSerialBus.DefaultBaudRate, &DefaultBaudRate); ++ ACPI_MOVE_16_TO_16(&Descriptor->UartSerialBus.TypeSpecificFlags, &TypeSpecificFlags); ++ ACPI_MOVE_16_TO_16(&Descriptor->UartSerialBus.RxFifoSize, &RxFifoSize); ++ ACPI_MOVE_16_TO_16(&Descriptor->UartSerialBus.TxFifoSize, &TxFifoSize); ++ + return (Rnode); + } +diff --git a/source/compiler/aslrestype2w.c b/source/compiler/aslrestype2w.c +index 79d7bcc..77acbcc 100644 +--- a/source/compiler/aslrestype2w.c ++++ b/source/compiler/aslrestype2w.c +@@ -85,6 +85,12 @@ RsDoWordIoDescriptor ( + UINT8 *OptionalFields; + UINT16 StringLength = 0; + UINT32 OptionIndex = 0; ++ UINT16 ResourceLength = 0; ++ UINT16 Minimum = 0; ++ UINT16 Maximum = 0; ++ UINT16 AddressLength = 0; ++ UINT16 Granularity = 0; ++ UINT16 TranslationOffset = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -104,8 +110,7 @@ RsDoWordIoDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); +- Descriptor->Address16.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS16) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS16) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -149,7 +154,7 @@ RsDoWordIoDescriptor ( + + case 5: /* Address Granularity */ + +- Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer; ++ Granularity = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); + GranOp = InitializerOp; +@@ -157,7 +162,7 @@ RsDoWordIoDescriptor ( + + case 6: /* Address Min */ + +- Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); + MinOp = InitializerOp; +@@ -165,7 +170,7 @@ RsDoWordIoDescriptor ( + + case 7: /* Address Max */ + +- Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); + MaxOp = InitializerOp; +@@ -173,14 +178,14 @@ RsDoWordIoDescriptor ( + + case 8: /* Translation Offset */ + +- Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer; ++ TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); + break; + + case 9: /* Address Length */ + +- Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); + LengthOp = InitializerOp; +@@ -192,7 +197,7 @@ RsDoWordIoDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address16.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -204,8 +209,7 @@ RsDoWordIoDescriptor ( + { + if (StringLength) + { +- Descriptor->Address16.ResourceLength = (UINT16) +- (Descriptor->Address16.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -265,13 +269,20 @@ RsDoWordIoDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- (UINT64) Descriptor->Address16.Minimum, +- (UINT64) Descriptor->Address16.Maximum, +- (UINT64) Descriptor->Address16.AddressLength, +- (UINT64) Descriptor->Address16.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address16.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.ResourceLength, &ResourceLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Minimum, &Minimum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Maximum, &Maximum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.AddressLength, &AddressLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Granularity, &Granularity); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + + OptionIndex + StringLength; + return (Rnode); +@@ -307,6 +318,12 @@ RsDoWordBusNumberDescriptor ( + UINT8 *OptionalFields; + UINT16 StringLength = 0; + UINT32 OptionIndex = 0; ++ UINT16 ResourceLength = 0; ++ UINT16 Minimum = 0; ++ UINT16 Maximum = 0; ++ UINT16 AddressLength = 0; ++ UINT16 Granularity = 0; ++ UINT16 TranslationOffset = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -326,8 +343,7 @@ RsDoWordBusNumberDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); +- Descriptor->Address16.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS16) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS16) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -364,8 +380,7 @@ RsDoWordBusNumberDescriptor ( + + case 4: /* Address Granularity */ + +- Descriptor->Address16.Granularity = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Granularity = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); + GranOp = InitializerOp; +@@ -373,8 +388,7 @@ RsDoWordBusNumberDescriptor ( + + case 5: /* Min Address */ + +- Descriptor->Address16.Minimum = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); + MinOp = InitializerOp; +@@ -382,8 +396,7 @@ RsDoWordBusNumberDescriptor ( + + case 6: /* Max Address */ + +- Descriptor->Address16.Maximum = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); + MaxOp = InitializerOp; +@@ -391,16 +404,14 @@ RsDoWordBusNumberDescriptor ( + + case 7: /* Translation Offset */ + +- Descriptor->Address16.TranslationOffset = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); + break; + + case 8: /* Address Length */ + +- Descriptor->Address16.AddressLength = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); + LengthOp = InitializerOp; +@@ -412,7 +423,7 @@ RsDoWordBusNumberDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address16.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -424,8 +435,7 @@ RsDoWordBusNumberDescriptor ( + { + if (StringLength) + { +- Descriptor->Address16.ResourceLength = (UINT16) +- (Descriptor->Address16.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -471,13 +481,20 @@ RsDoWordBusNumberDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- (UINT64) Descriptor->Address16.Minimum, +- (UINT64) Descriptor->Address16.Maximum, +- (UINT64) Descriptor->Address16.AddressLength, +- (UINT64) Descriptor->Address16.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address16.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.ResourceLength, &ResourceLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Minimum, &Minimum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Maximum, &Maximum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.AddressLength, &AddressLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Granularity, &Granularity); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + + OptionIndex + StringLength; + return (Rnode); +@@ -513,6 +530,12 @@ RsDoWordSpaceDescriptor ( + UINT8 *OptionalFields; + UINT16 StringLength = 0; + UINT32 OptionIndex = 0; ++ UINT16 Minimum = 0; ++ UINT16 Maximum = 0; ++ UINT16 AddressLength = 0; ++ UINT16 Granularity = 0; ++ UINT16 TranslationOffset = 0; ++ UINT16 ResourceLength = 0; + UINT32 i; + BOOLEAN ResSourceIndex = FALSE; + +@@ -531,8 +554,7 @@ RsDoWordSpaceDescriptor ( + * optional fields present + */ + OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); +- Descriptor->Address16.ResourceLength = (UINT16) +- (sizeof (AML_RESOURCE_ADDRESS16) - ++ ResourceLength = (UINT16) (sizeof (AML_RESOURCE_ADDRESS16) - + sizeof (AML_RESOURCE_LARGE_HEADER)); + + /* Process all child initialization nodes */ +@@ -581,8 +603,7 @@ RsDoWordSpaceDescriptor ( + + case 6: /* Address Granularity */ + +- Descriptor->Address16.Granularity = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Granularity = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_GRANULARITY, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); + GranOp = InitializerOp; +@@ -590,8 +611,7 @@ RsDoWordSpaceDescriptor ( + + case 7: /* Min Address */ + +- Descriptor->Address16.Minimum = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Minimum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); + MinOp = InitializerOp; +@@ -599,8 +619,7 @@ RsDoWordSpaceDescriptor ( + + case 8: /* Max Address */ + +- Descriptor->Address16.Maximum = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ Maximum = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); + MaxOp = InitializerOp; +@@ -608,16 +627,14 @@ RsDoWordSpaceDescriptor ( + + case 9: /* Translation Offset */ + +- Descriptor->Address16.TranslationOffset = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_TRANSLATION, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); + break; + + case 10: /* Address Length */ + +- Descriptor->Address16.AddressLength = +- (UINT16) InitializerOp->Asl.Value.Integer; ++ AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; + RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH, + CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); + LengthOp = InitializerOp; +@@ -629,7 +646,7 @@ RsDoWordSpaceDescriptor ( + { + OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; + OptionIndex++; +- Descriptor->Address16.ResourceLength++; ++ ResourceLength++; + ResSourceIndex = TRUE; + } + break; +@@ -641,8 +658,7 @@ RsDoWordSpaceDescriptor ( + { + if (StringLength) + { +- Descriptor->Address16.ResourceLength = (UINT16) +- (Descriptor->Address16.ResourceLength + StringLength); ++ ResourceLength = (UINT16) (ResourceLength + StringLength); + + strcpy ((char *) + &OptionalFields[OptionIndex], +@@ -688,13 +704,20 @@ RsDoWordSpaceDescriptor ( + /* Validate the Min/Max/Len/Gran values */ + + RsLargeAddressCheck ( +- (UINT64) Descriptor->Address16.Minimum, +- (UINT64) Descriptor->Address16.Maximum, +- (UINT64) Descriptor->Address16.AddressLength, +- (UINT64) Descriptor->Address16.Granularity, ++ Minimum, ++ Maximum, ++ AddressLength, ++ Granularity, + Descriptor->Address16.Flags, + MinOp, MaxOp, LengthOp, GranOp, Op); + ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.ResourceLength, &ResourceLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Minimum, &Minimum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Maximum, &Maximum); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.AddressLength, &AddressLength); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.Granularity, &Granularity); ++ ACPI_MOVE_16_TO_16(&Descriptor->Address16.TranslationOffset, &TranslationOffset); ++ + Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + + OptionIndex + StringLength; + return (Rnode); +diff --git a/source/include/acmacros.h b/source/include/acmacros.h +index ee9e745..67fb983 100644 +--- a/source/include/acmacros.h ++++ b/source/include/acmacros.h +@@ -107,7 +107,8 @@ + + /* 32-bit source, 16/32/64 destination */ + +-#define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ ++#define ACPI_MOVE_32_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\ ++ (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];} + + #define ACPI_MOVE_32_TO_32(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[3];\ + (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[2];\ +@@ -122,9 +123,13 @@ + + /* 64-bit source, 16/32/64 destination */ + +-#define ACPI_MOVE_64_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ ++#define ACPI_MOVE_64_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\ ++ (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];} + +-#define ACPI_MOVE_64_TO_32(d, s) ACPI_MOVE_32_TO_32(d, s) /* Truncate to 32 */ ++#define ACPI_MOVE_64_TO_32(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\ ++ (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];\ ++ (( UINT8 *)(void *)(d))[2] = ((UINT8 *)(void *)(s))[5];\ ++ (( UINT8 *)(void *)(d))[3] = ((UINT8 *)(void *)(s))[4];} + + #define ACPI_MOVE_64_TO_64(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[7];\ + (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[6];\ +@@ -151,7 +156,9 @@ + + /* 32-bit source, 16/32/64 destination */ + +-#define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */ ++#define ACPI_MOVE_32_TO_16(d, s) {(( UINT8 *)(void *)(d))[0] = ((UINT8 *)(void *)(s))[0];\ ++ (( UINT8 *)(void *)(d))[1] = ((UINT8 *)(void *)(s))[1];} ++ + #define ACPI_MOVE_32_TO_32(d, s) *(UINT32 *)(void *)(d) = *(UINT32 *)(void *)(s) + #define ACPI_MOVE_32_TO_64(d, s) *(UINT64 *)(void *)(d) = *(UINT32 *)(void *)(s) + +diff --git a/source/include/platform/aclinux.h b/source/include/platform/aclinux.h +index 3bc85bc..1bace7f 100644 +--- a/source/include/platform/aclinux.h ++++ b/source/include/platform/aclinux.h +@@ -81,13 +81,14 @@ + #include <stdlib.h> + #include <ctype.h> + #include <unistd.h> ++#include <endian.h> + + /* Host-dependent types and defines for user-space ACPICA */ + + #define ACPI_FLUSH_CPU_CACHE() + #define ACPI_CAST_PTHREAD_T(pthread) ((ACPI_THREAD_ID) (pthread)) + +-#if defined(__ia64__) || defined(__x86_64__) ++#if __SIZEOF_LONG__ == 8 + #define ACPI_MACHINE_WIDTH 64 + #define COMPILER_DEPENDENT_INT64 long + #define COMPILER_DEPENDENT_UINT64 unsigned long +@@ -98,6 +99,10 @@ + #define ACPI_USE_NATIVE_DIVIDE + #endif + ++#if __BYTE_ORDER == __BIG_ENDIAN ++#define ACPI_BIG_ENDIAN ++#endif ++ + #ifndef __cdecl + #define __cdecl + #endif +-- +1.7.12.1 + diff --git a/meta-linaro/recipes-extra/acpica/files/debian-unaligned.patch b/meta-linaro/recipes-extra/acpica/files/debian-unaligned.patch new file mode 100644 index 00000000..31b9fe56 --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/debian-unaligned.patch @@ -0,0 +1,163 @@ +Patch carried over from the prior iasl package and updated. This allows +for builds on systems requiring aligned memory access. Please see +http://lists.acpica.org/pipermail/devel/2010-July/000159.html. Resolves +BZ#865013 and BZ#856856. +-- + +Add more platforms to the list of the ones requiring aligned memory access. +Also fix callsites where wrong assumptions where made in terms of aligment. + +Signed-off-by: Mattia Dongili <malattia@linux.it> +Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> +--- + source/compiler/asltree.c | 15 ++++++++++----- + source/components/executer/exoparg2.c | 12 +++++++++--- + source/include/actypes.h | 26 +++++++++++++------------- + 3 file modificati, 32 inserzioni(+), 21 rimozioni(-) + +diff --git a/source/compiler/asltree.c b/source/compiler/asltree.c +index ebf87f3..fd859d7 100644 +--- a/source/compiler/asltree.c ++++ b/source/compiler/asltree.c +@@ -577,28 +577,31 @@ TrCreateValuedLeafNode ( + "\nCreateValuedLeafNode Ln/Col %u/%u NewNode %p Op %s Value %8.8X%8.8X ", + Op->Asl.LineNumber, Op->Asl.Column, Op, UtGetOpName(ParseOpcode), + ACPI_FORMAT_UINT64 (Value)); +- Op->Asl.Value.Integer = Value; + + switch (ParseOpcode) + { + case PARSEOP_STRING_LITERAL: + +- DbgPrint (ASL_PARSE_OUTPUT, "STRING->%s", Value); ++ Op->Asl.Value.String = (ACPI_STRING) (ACPI_SIZE) Value; ++ DbgPrint (ASL_PARSE_OUTPUT, "STRING->%s", Op->Asl.Value.String); + break; + + case PARSEOP_NAMESEG: + +- DbgPrint (ASL_PARSE_OUTPUT, "NAMESEG->%s", Value); ++ Op->Asl.Value.String = (ACPI_STRING) (ACPI_SIZE) Value; ++ DbgPrint (ASL_PARSE_OUTPUT, "NAMESEG->%s", Op->Asl.Value.String); + break; + + case PARSEOP_NAMESTRING: + +- DbgPrint (ASL_PARSE_OUTPUT, "NAMESTRING->%s", Value); ++ Op->Asl.Value.String = (ACPI_STRING) (ACPI_SIZE) Value; ++ DbgPrint (ASL_PARSE_OUTPUT, "NAMESTRING->%s", Op->Asl.Value.String); + break; + + case PARSEOP_EISAID: + +- DbgPrint (ASL_PARSE_OUTPUT, "EISAID->%s", Value); ++ Op->Asl.Value.String = (ACPI_STRING) (ACPI_SIZE) Value; ++ DbgPrint (ASL_PARSE_OUTPUT, "EISAID->%s", Op->Asl.Value.String); + break; + + case PARSEOP_METHOD: +@@ -608,11 +610,13 @@ TrCreateValuedLeafNode ( + + case PARSEOP_INTEGER: + ++ Op->Asl.Value.Integer = Value; + DbgPrint (ASL_PARSE_OUTPUT, "INTEGER"); + break; + + default: + ++ Op->Asl.Value.Integer = Value; + break; + } + +diff --git a/source/components/executer/exoparg2.c b/source/components/executer/exoparg2.c +index e55f40c..ed5b1fd 100644 +--- a/source/components/executer/exoparg2.c ++++ b/source/components/executer/exoparg2.c +@@ -175,6 +176,8 @@ AcpiExOpcode_2A_2T_1R ( + ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0]; + ACPI_OPERAND_OBJECT *ReturnDesc1 = NULL; + ACPI_OPERAND_OBJECT *ReturnDesc2 = NULL; ++ UINT64 ReturnValue1 = 0; ++ UINT64 ReturnValue2 = 0; + ACPI_STATUS Status; + + +@@ -208,8 +211,10 @@ AcpiExOpcode_2A_2T_1R ( + + Status = AcpiUtDivide (Operand[0]->Integer.Value, + Operand[1]->Integer.Value, +- &ReturnDesc1->Integer.Value, +- &ReturnDesc2->Integer.Value); ++ &ReturnValue1, &ReturnValue2); ++ ReturnDesc1->Integer.Value = ReturnValue1; ++ ReturnDesc2->Integer.Value = ReturnValue2; ++ + if (ACPI_FAILURE (Status)) + { + goto Cleanup; +@@ -283,6 +285,7 @@ AcpiExOpcode_2A_1T_1R ( + ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0]; + ACPI_OPERAND_OBJECT *ReturnDesc = NULL; + UINT64 Index; ++ UINT64 ReturnValue = 0; + ACPI_STATUS Status = AE_OK; + ACPI_SIZE Length = 0; + +@@ -328,7 +333,8 @@ AcpiExOpcode_2A_1T_1R ( + Status = AcpiUtDivide (Operand[0]->Integer.Value, + Operand[1]->Integer.Value, + NULL, +- &ReturnDesc->Integer.Value); ++ &ReturnValue); ++ ReturnDesc->Integer.Value = ReturnValue; + break; + + case AML_CONCAT_OP: /* Concatenate (Data1, Data2, Result) */ +diff --git a/source/include/actypes.h b/source/include/actypes.h +index 07fb7d5..08bdf2f 100644 +--- a/source/include/actypes.h ++++ b/source/include/actypes.h +@@ -142,6 +142,19 @@ typedef COMPILER_DEPENDENT_INT64 INT64; + */ + #define ACPI_THREAD_ID UINT64 + ++/* ++ * In the case of the Itanium Processor Family (IPF), the hardware does not ++ * support misaligned memory transfers. Set the MISALIGNMENT_NOT_SUPPORTED flag ++ * to indicate that special precautions must be taken to avoid alignment faults. ++ * (IA64 or ia64 is currently used by existing compilers to indicate IPF.) ++ * ++ * Note: EM64T and other X86-64 processors support misaligned transfers, ++ * so there is no need to define this flag. ++ */ ++#if defined (__IA64__) || defined (__ia64__) || defined(__alpha__) || defined(__sparc__) || defined(__hppa__) || defined(__arm__) ++#define ACPI_MISALIGNMENT_NOT_SUPPORTED ++#endif ++ + + /******************************************************************************* + * +@@ -168,19 +181,6 @@ typedef UINT64 ACPI_PHYSICAL_ADDRESS; + #define ACPI_SIZE_MAX ACPI_UINT64_MAX + #define ACPI_USE_NATIVE_DIVIDE /* Has native 64-bit integer support */ + +-/* +- * In the case of the Itanium Processor Family (IPF), the hardware does not +- * support misaligned memory transfers. Set the MISALIGNMENT_NOT_SUPPORTED flag +- * to indicate that special precautions must be taken to avoid alignment faults. +- * (IA64 or ia64 is currently used by existing compilers to indicate IPF.) +- * +- * Note: EM64T and other X86-64 processors support misaligned transfers, +- * so there is no need to define this flag. +- */ +-#if defined (__IA64__) || defined (__ia64__) +-#define ACPI_MISALIGNMENT_NOT_SUPPORTED +-#endif +- + + /******************************************************************************* + * +-- +1.7.12.1 + diff --git a/meta-linaro/recipes-extra/acpica/files/fix_ftbfs_debian-hurd.patch b/meta-linaro/recipes-extra/acpica/files/fix_ftbfs_debian-hurd.patch new file mode 100644 index 00000000..0f34ea27 --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/fix_ftbfs_debian-hurd.patch @@ -0,0 +1,18 @@ +Fix FTBFS on hurd-i386. +--- + source/include/platform/acenv.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: acpica-unix-20130517/source/include/platform/acenv.h +=================================================================== +--- acpica-unix-20130517.orig/source/include/platform/acenv.h 2013-05-28 20:56:14.000000000 -0600 ++++ acpica-unix-20130517/source/include/platform/acenv.h 2013-05-28 20:56:14.000000000 -0600 +@@ -148,7 +148,7 @@ + * + *****************************************************************************/ + +-#if defined(_LINUX) || defined(__linux__) ++#if defined(_LINUX) || defined(__linux__) || defined(__GNU__) + #include "aclinux.h" + + #elif defined(_APPLE) || defined(__APPLE__) diff --git a/meta-linaro/recipes-extra/acpica/files/fix_ftbfs_debian-kfreebsd.patch b/meta-linaro/recipes-extra/acpica/files/fix_ftbfs_debian-kfreebsd.patch new file mode 100644 index 00000000..461bf4d5 --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/fix_ftbfs_debian-kfreebsd.patch @@ -0,0 +1,38 @@ +Package: acpica-unix +Severity: important +Version: 20060912-2 +Tags: patch + + +Hi, + +the current version fails to build on GNU/kFreeBSD. + +It needs small tweak to define uintptr_t, see bellow. + +It would also be nice if you can ask upstream +to include this change. + +Thanks in advance + + Petr + + +--- + source/include/platform/acenv.h | 3 +++ + 1 file changed, 3 insertions(+) + +Index: acpica-unix/source/include/platform/acenv.h +=================================================================== +--- acpica-unix.orig/source/include/platform/acenv.h 2013-01-31 15:29:53.000000000 -0700 ++++ acpica-unix/source/include/platform/acenv.h 2013-01-31 15:29:53.000000000 -0700 +@@ -136,6 +136,9 @@ + + + /*! [Begin] no source code translation */ ++#if defined(__GLIBC__) ++#include <stdint.h> ++#endif + + /****************************************************************************** + * diff --git a/meta-linaro/recipes-extra/acpica/files/name-miscompare.patch b/meta-linaro/recipes-extra/acpica/files/name-miscompare.patch new file mode 100644 index 00000000..4dee585c --- /dev/null +++ b/meta-linaro/recipes-extra/acpica/files/name-miscompare.patch @@ -0,0 +1,28 @@ +On big-endian machines, a test case looking for the methods _L1D and _E1D +in the same scope would fail (see tests/misc/badcode.asl:184). The names +to be compared were being treated as 32-bit ints, and not strings. Hence, +the characters were re-ordered incorrectly, mismatching the assumptions +made in the remainder of the function. + +Index: acpica-unix-20130517/source/compiler/aslanalyze.c +=================================================================== +--- acpica-unix-20130517.orig/source/compiler/aslanalyze.c 2013-05-28 20:56:34.000000000 -0600 ++++ acpica-unix-20130517/source/compiler/aslanalyze.c 2013-05-28 20:56:34.000000000 -0600 +@@ -446,7 +446,7 @@ + + /* Need a null-terminated string version of NameSeg */ + +- ACPI_MOVE_32_TO_32 (Name, &Op->Asl.NameSeg); ++ ACPI_MOVE_NAME (Name, &Op->Asl.NameSeg); + Name[ACPI_NAME_SIZE] = 0; + + /* +@@ -473,7 +473,7 @@ + * We are now sure we have an _Lxx or _Exx. + * Create the target name that would cause collision (Flip E/L) + */ +- ACPI_MOVE_32_TO_32 (Target, Name); ++ ACPI_MOVE_NAME (Target, Name); + + /* Inject opposite letter ("L" versus "E") */ + |