kamkow1/my-os-project2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Integrate uACPI

Browse Source
This commit is contained in:
Kamil Kowalczyk
2025-08-17 18:37:57 +02:00
parent 069870cd0d
commit 92ccd189e7
166 changed files with 42104 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

415
kernel/hal/x86_64/uACPI/tests/test-cases/address-spaces-work.asl Normal file
View File

@ -0,0 +1,415 @@
// Name: Support for various address spaces works
// Expect: str => check-address-spaces-work
DefinitionBlock ("x.aml", "SSDT", 1, "uTEST", "ASPTESTS", 0xF0F0F0F0)
{
Method (MAIN) {
// Skip for non-uacpi test runners
Return ("check-address-spaces-work")
}
Method (DOIP, 1, Serialized) {
If (Arg0 == 0) {
Local0 = "DEADBEE0"
Local1 = 0xDEADBEE0
} Else {
Local0 = "DEADBEEF"
Local1 = 0xDEADBEEF
}
OperationRegion (IPMR, IPMI, 0xDEADBEE0, 10)
Field (IPMR, BufferAcc, NoLock, Preserve) {
CMD0, 120,
// Offset = base + 0xF
CMD1, 1234,
}
Name (REQ, Buffer (32) { })
Name (RET, 0)
REQ = Concatenate("IPMICommand", Local0)
If (Arg0 == 0) {
Local0 = CMD0 = REQ
} Else {
Local0 = CMD1 = REQ
}
If (SizeOf(Local0) != 66) {
Printf("Unexpected IPMI response size %o", SizeOf(Local0))
Return (Zero)
}
RET = Local0
If (RET != Local1) {
Printf("Unexpected IMPI response %o, expected %o", RET, Local1)
Return (Zero)
}
Return (Ones)
}
Device (GPO0)
{
Name (_HID, "INT33FC" /* Intel Baytrail GPIO Controller */)
Name (_DDN, "ValleyView General Purpose Input/Output (GPIO) controller")
Name (_UID, 0)
}
Device (GPO1)
{
Name (_HID, "INT33FC" /* Intel Baytrail GPIO Controller */)
Name (_DDN, "ValleyView GPNCORE controller")
Name (_UID, 1)
}
Method (DGIO, 0, Serialized) {
OperationRegion (GPOP, GeneralPurposeIo, Zero, 0x06)
Field (GPOP, ByteAcc, NoLock, Preserve)
{
Connection (
GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly,
"\\GPO0", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0002, 0x0003, 0x0004, 0x0005, 0x0006
}
),
CCU0, 1,
CCU1, 3,
CCU2, 1,
Connection (
GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly,
"\\GPO1", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x005F
}
),
CCU3, 1
}
CCU0 = 1
CCU1 = 2
CCU2 = 0
Local0 = CCU0
If (Local0 != 1) {
Printf("Bad CCU0 return %o", Local0)
Return (Zero)
}
Local0 = CCU1
If (Local0 != 2) {
Printf ("Bad CCU1 return %o", Local0)
Return (Zero)
}
Local0 = CCU2
If (Local0 != 0) {
Printf ("Bad CCU2 return %o", Local0)
Return (Zero)
}
Local0 = CCU3
if (Local0 != 0) {
Printf ("Bad CCU3 value %o", Local0)
Return (Zero)
}
Return (Ones)
}
Method (DPCC, 0, Serialized) {
OperationRegion (GPOP, PCC, 0xCA, 0xFF)
Field (GPOP, DWordAcc, NoLock, Preserve)
{
H, 8,
E, 8,
L0, 8,
L1, 8,
O, 8,
Offset(12),
CMD, 32,
}
Field (GPOP, DWordAcc, NoLock, Preserve)
{
HELL, 48,
}
H = "H"
E = "E"
L0 = "L"
L1 = "L"
O = "O"
If (ToString(HELL) != "HELLO") {
Printf ("Unexpected HELL value %o", ToString(HELL))
Return (Zero)
}
// Invoke the test runner handler
CMD = 0xDEADBEEF
// We expect it to modify the CMD field as a response
If (CMD != 0xBEEFDEAD) {
Printf ("Unexpected CMD value %o", CMD)
Return (Zero)
}
Return (Ones)
}
Method (DPRM, 0, Serialized) {
OperationRegion (GPOP, PlatformRtMechanism, 0x00, 0xFF)
Field (GPOP, BufferAcc, NoLock, Preserve)
{
DEAD, 80,
}
Local0 = DEAD = "helloworld"
Printf("Got a PRM response: %o", Local0)
If (SizeOf(Local0) != 26) {
Printf ("Unexpected Local0 size %o", SizeOf(Local0))
Return (Zero)
}
If (ToString(Local0) != "goodbyeworld") {
Printf ("Unexpected Local0 value %o", ToString(Local0))
Return (Zero)
}
Return (Ones)
}
Method (DFHW, 0, Serialized) {
OperationRegion (GPOP, FFixedHW, 0xCAFEBABE, 0xFEFECACA)
Field (GPOP, BufferAcc, NoLock, Preserve)
{
X, 1,
}
Local0 = X = "someguidandstuff"
Printf("Got a FFixedHW response: %o", Local0)
If (SizeOf(Local0) != 256) {
Printf ("Unexpected Local0 size %o", SizeOf(Local0))
Return (Zero)
}
If (ToString(Local0) != "ok") {
Printf ("Unexpected Local0 value %o", ToString(Local0))
Return (Zero)
}
Return (Ones)
}
Scope (_SB) {
Device (I2C0)
{
Name (_HID, "INT34B2")
Name (_UID, 0)
}
Device (I2C1)
{
Name (_HID, "80860F41" /* Intel Baytrail I2C Host Controller */)
Name (_CID, "80860F41" /* Intel Baytrail I2C Host Controller */)
Name (_DDN, "Intel(R) I2C Controller #5 - 80860F45")
Name (_UID, 1)
}
}
Name (RES1, ResourceTemplate ()
{
I2cSerialBusV2 (0x0008, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.I2C0",
0x00, ResourceConsumer, , Exclusive,
)
})
Name (RES2, ResourceTemplate ()
{
I2cSerialBusV2 (0x0040, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
})
Method (DGSB, 0, Serialized) {
Method (CHEK, 3) {
If (SizeOf(Arg0) != Arg1) {
Printf(
"Bad resulting buffer length %o, expected %o",
SizeOf(Arg0), Arg1
)
Return (Zero)
}
Name (INT, 0)
INT = Arg0
If (INT != Arg2) {
Printf("Unexpected response %o, expected %o", INT, Arg2)
Return (Zero)
}
Return (Ones)
}
OperationRegion (RCH1, GenericSerialBus, 0x100, 0x0100)
Field (RCH1, BufferAcc, NoLock, Preserve)
{
Connection (RES1),
Offset (0x11),
// Command == 0x111
AccessAs (BufferAcc, AttribQuick),
CMD0, 128,
// Command == 0x121
AccessAs (BufferAcc, AttribSendReceive),
CMD1, 8,
// Command == 0x122
AccessAs (BufferAcc, AttribByte),
CMD2, 16,
// Command == 0x124
AccessAs (BufferAcc, AttribWord),
CMD3, 32,
// Command == 0x128
AccessAs (BufferAcc, AttribBlock),
CMD4, 2048,
// Command == 0x228
AccessAs (BufferAcc, AttribProcessCall),
CMD5, 8,
// Command == 0x229
AccessAs (BufferAcc, AttribBlockProcessCall),
CMD6, 144,
Connection (RES2),
// Command == 0x23B
AccessAs (BufferAcc, AttribBytes(15)),
CMD7, 8,
// Command == 0x23C
AccessAs (BufferAcc, AttribRawBytes(255)),
CMD8, 8,
// Command == 0x23D
AccessAs (BufferAcc, AttribRawProcessBytes(123)),
CMD9, 8,
}
Local0 = CMD0 = 0x111
If (CHEK(Local0, 2, 0x112) != Ones) {
Return (Zero)
}
Local0 = 0x121
Local0 = CMD1 = Local0
If (CHEK(Local0, 3, 0x122) != Ones) {
Return (Zero)
}
Local0 = CMD2 = 0x122
If (CHEK(Local0, 3, 0x123) != Ones) {
Return (Zero)
}
Local0 = CMD3
If (CHEK(Local0, 4, 0x125) != Ones) {
Return (Zero)
}
Local0 = CMD4
If (CHEK(Local0, 257, 0x129) != Ones) {
Return (Zero)
}
Local0 = CMD5 = 0x228
If (CHEK(Local0, 4, 0x229) != Ones) {
Return (Zero)
}
Local0 = CMD6
If (CHEK(Local0, 257, 0x22A) != Ones) {
Return (Zero)
}
Local0 = CMD7 = 0x23B
If (CHEK(Local0, 15 + 2, 0x23C) != Ones) {
Return (Zero)
}
Local0 = CMD8
If (CHEK(Local0, 255 + 2, 0x23D) != Ones) {
Return (Zero)
}
Local0 = CMD9
If (CHEK(Local0, 255 + 2, 0x23E) != Ones) {
Return (Zero)
}
Return (Ones)
}
/*
* Arg0 -> The address space type
* Return -> Ones on succeess, Zero on failure
*/
Method (CHEK, 1, Serialized) {
Switch (Arg0) {
Case (7) { // IPMI
Local0 = DOIP(0)
If (Local0 != Ones) {
Break
}
Local0 = DOIP(1)
Break
}
Case (8) { // General Purpose IO
Local0 = DGIO()
Break
}
Case (9) { // Generic Serial Bus
Local0 = DGSB()
Break
}
Case (0x0A) { // PCC
Local0 = DPCC()
Break
}
Case (0x0B) { // PRM
Local0 = DPRM()
Break
}
Case (0x7F) { // FFixedHW
Local0 = DFHW()
Break
}
}
If (Local0 != Ones) {
Printf("Address space %o failed: expected '%o', got '%o'!",
Arg0, Ones, Local0)
Return (Zero)
}
Printf("Address space %o OK", ToHexString(Arg0))
Return (Ones)
}
}

71
kernel/hal/x86_64/uACPI/tests/test-cases/complex-package.asl Normal file
View File

@ -0,0 +1,71 @@
// Name: Nested Package Doesn't Leak Memory
// Expect: int => 1
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method(GPKG) {
Local1 = 10
Local0 = Package (Local1) {
0x123,
0x321,
Package {
0x321,
"123",
Package {
0x321,
Package {
0x321,
"123",
Package {
0x321,
"123",
Package {
0x321,
Package {
0x321,
"123",
Package (Local1) {
0x321,
"123",
999,
},
999,
},
"123",
999,
},
999,
},
999,
},
"123",
999,
},
999,
},
"Hello world",
Package {
0x321,
"Hello",
},
Package {
0x321,
"World",
},
Package {
Buffer (Local1) { 0xFF },
0xDEADBEEF,
},
Buffer { 1, 2, 3 }
}
Return (Local0)
}
Method (MAIN) {
Local0 = GPKG()
Debug = Local0
Local0 = 1
Return (Local0)
}
}

127
kernel/hal/x86_64/uACPI/tests/test-cases/concat-res.asl Normal file
View File

@ -0,0 +1,127 @@
// Name: Concatenate Resources
// Expect: int => 1
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (BUF0, ResourceTemplate ()
{
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000,
0x0000,
0x00FF,
0x0000,
0x0100,
,, _Y00)
DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x00000000,
0x00000000,
0x00000CF7,
0x00000000,
0x00000CF8,
1, "\\SOME.PATH",, TypeStatic, DenseTranslation)
IO (Decode16,
0x0CF8,
0x0CF8,
0x01,
0x08,
)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000,
0x000A0000,
0x000BFFFF,
0x00000000,
0x00020000,
123, "^^^^^^^^^ANOT.ER.PATH", , AddressRangeMemory, TypeStatic)
})
Name (IIC0, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C0",
0x00, ResourceConsumer, _Y10, Exclusive,
)
})
Name (RBUF, ResourceTemplate ()
{
I2cSerialBusV2 (0x0029, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C0",
0x00, ResourceConsumer, , Exclusive,
)
GpioInt (Level, ActiveHigh, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.GPI0", 0x00, ResourceConsumer, ,
)
{
0x012A
}
GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly,
"\\_SB.PCI0.GPI0", 0x00, ResourceConsumer, ,
)
{
0x002F
}
GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly,
"\\_SB.PCI0.GPI0", 0x00, ResourceConsumer, ,
)
{
0x0124
}
})
// src0, src1, dst
Method (CHEK, 3)
{
Local0 = (SizeOf(Arg0) + SizeOf(Arg1)) - 2
If (Local0 != SizeOf(Arg2)) {
Printf("Invalid final buffer size: %o, expected %o",
Local0, SizeOf(Arg2))
Return (0)
}
Local0 = 0
Local1 = 0
While (Local0 < (SizeOf(Arg0) - 2)) {
Local2 = DerefOf(Arg0[Local0])
Local3 = DerefOf(Arg2[Local1])
If (Local2 != Local3) {
Printf("Byte src=%o (dst=%o) mismatch, expected %o got %o",
Local0, Local1, ToHexString(Local2), ToHexString(Local3))
Return (0)
}
Local0 += 1
Local1 += 1
}
Local0 = 0
While (Local0 < SizeOf(Arg1)) {
Local2 = DerefOf(Arg1[Local0])
Local3 = DerefOf(Arg2[Local1])
If (Local2 != Local3) {
Printf("Byte src=%o (dst=%o) mismatch, expected %o got %o",
Local0, Local1, ToHexString(Local2), ToHexString(Local3))
Return (0)
}
Local0 += 1
Local1 += 1
}
Return (1)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = ConcatenateResTemplate(BUF0, IIC0)
If (CHEK(BUF0, IIC0, Local0) != 1) {
Return (0)
}
Local1 = ConcatenateResTemplate(Local0, RBUF)
Return(CHEK(Local0, RBUF, Local1))
}
}

34
kernel/hal/x86_64/uACPI/tests/test-cases/copy-a-method.asl Normal file
View File

@ -0,0 +1,34 @@
// Name: Copy a local method and execute it
// Expect: int => 3735928559
DefinitionBlock ("x.aml", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (TEST, "Hello world!")
Method (GETX) {
Return (1)
}
Method (COPY) {
Method (GETX, 1, Serialized) {
Name (Y, 0xDEAD0000)
Y += Arg0
Return (Y)
}
Return (RefOf(GETX))
}
Method (COP1) {
Local0 = COPY()
Return (DerefOf(Local0))
}
Method (MAIN, 0, NotSerialized)
{
Local0 = COP1()
CopyObject(Local0, TEST)
Return (TEST(0xBEEF))
}
}

70
kernel/hal/x86_64/uACPI/tests/test-cases/copy-object-opregion.asl Normal file
View File

@ -0,0 +1,70 @@
// Name: CopyObject with Operation Region works
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (REPL, 1) {
Arg0 = 123
}
Method (CAS0) {
OperationRegion(MYRE, SystemMemory, 0, 128)
Field (MYRE, AnyAcc, NoLock) {
FILD, 32
}
FILD = 1
CopyObject(123, MYRE)
}
CAS0()
Method (CAS1) {
OperationRegion(MYRE, SystemMemory, 0, 128)
Field (MYRE, AnyAcc, NoLock) {
FILD, 32
}
FILD = 1
REPL(RefOf(MYRE))
}
CAS1()
Method (CAS2) {
OperationRegion(MYRE, SystemMemory, 0, 128)
Field (MYRE, AnyAcc, NoLock) {
FILD, 32
}
FILD = 1
Name (FAKE, 123)
CopyObject(MYRE, FAKE)
Field (FAKE, AnyAcc, NoLock) {
FAKF, 32
}
REPL(RefOf(MYRE))
FAKF = 1
}
CAS2()
Method (CAS3) {
OperationRegion(MYR0, SystemMemory, 0, 128)
OperationRegion(MYR1, SystemMemory, 0, 128)
CopyObject(123, MYR1)
}
CAS3()
Method (CAS4) {
OperationRegion(MYRE, SystemMemory, 0, 128)
Field (MYRE, AnyAcc, NoLock) {
FILD, 32
}
FILD = 1
CopyObject(FILD, MYRE)
FILD = 1
}
CAS4()
Name (MAIN, 0)
}

27
kernel/hal/x86_64/uACPI/tests/test-cases/copy-object-self.asl Normal file
View File

@ -0,0 +1,27 @@
// Name: CopyObject on yourself works
// Expect: str => Hello World
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (BAR, 1, Serialized) {
Debug = "Enter BAR"
CopyObject (Arg0, BAR)
Debug = "Leave BAR"
}
Method (FOO) {
Debug = "Enter FOO"
CopyObject("Hello", FOO)
BAR(" World")
Debug = "Leave FOO"
Return (0x123)
}
Method (MAIN) {
Local0 = FOO()
Printf("First invocation of FOO returned %o", Local0)
Return (Concatenate(FOO, BAR))
}
}

31
kernel/hal/x86_64/uACPI/tests/test-cases/copy-object-to-predefined.asl Normal file
View File

@ -0,0 +1,31 @@
// Name: CopyObject to predefined works
// Expect: str => HelloWorld
DefinitionBlock ("x.aml", "SSDT", 1, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (HELO) {
Return ("Hello")
}
Method (WRLD) {
Return ("World")
}
Method (MAIN) {
OperationRegion(NVSM, SystemMemory, 0x100000, 128)
Field (NVSM, ByteAcc, Lock, WriteAsZeros) {
FILD, 8,
}
FILD = 0xFF
CopyObject(HELO, \)
CopyObject(WRLD, _GL)
If (FILD != 0xFF) {
Return ("Locked field read-back failed")
}
Return (Concatenate(\(), _GL()))
}
}

84
kernel/hal/x86_64/uACPI/tests/test-cases/duplicate-named.asl Normal file
View File

@ -0,0 +1,84 @@
// Name: Duplicate named objects are skipped correctly
// Expect: int => 11
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (MAIN, 0)
Name (TEST, "Hello World")
Device (FOO) {
ThermalZone (BAR) {
Name (TEST, "Hello World")
}
}
// These all attempt to create duplicate objects
Name (FOO.BAR.TEST, "duplicated test")
MAIN += 1
Method (TEST, 0, Serialized) {
Debug = "Why is this executed?"
Name (TEST, 123)
CopyObject("Method didn't get skipped", MAIN)
Return (333)
}
Debug = "Ok, still here"
MAIN += 1
ThermalZone (TEST) {
Local0 = 123
Debug = Local0
CopyObject("???", MAIN)
}
ThermalZone (TEST) { }
MAIN += 1
Processor (FOO.BAR.TEST, 0x02, 0x00000410, 0x06) { }
MAIN += 1
Processor (\TEST, 0x01, 0x00000410, 0x06) {
Local2 = Package { 1, 2, 3 }
Debug = Local2
}
Device (\FOO.BAR.TEST)
{
Name (_HID, EisaId ("PNP0C0D"))
}
MAIN += 1
Device (\TEST) { }
// Alias to an object that doesn't exist, but new name is valid
Alias(ZOO, BAR)
Alias(PATH.THAT.DOES.NOT.EXIS.T, \BAZ)
MAIN += 1
// Alias to an object that does exist, but new name alrady exists
Alias(\TEST, \MAIN)
// Alias to a non existant object and name also already exists
Alias(ZOO, \TEST)
Alias(PATH.THAT.DOES.NOT.EXIS.T, \FOO.BAR.TEST)
MAIN += 1
Mutex(TEST, 15)
Debug = "Just a bit left"
Event(TEST)
MAIN += 1
OperationRegion(TEST, SystemMemory, 0x100000, 128)
DataTableRegion(FOO.BAR.TEST, "DSDT", "", "")
Local0 = Buffer (256) { }
CreateBitField(Local0, 111, TEST)
CreateByteField(Local0, 111, TEST)
MAIN += 1
CreateDWordField(Local0, 111, TEST)
CreateQWordField(Local0, 111, TEST)
MAIN += 1
CreateField(Local0, 111, 11, FOO.BAR.TEST)
MAIN += 1
Debug = "Made it to the end!"
}

21
kernel/hal/x86_64/uACPI/tests/test-cases/empty-objects.asl Normal file
View File

@ -0,0 +1,21 @@
// Name: Empty objects behave correctly
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (EMPT) { }
Method (MAIN) {
Local0 = EMPT()
Debug = Local0
Local0 = Package (0) { }
Debug = Local0
Local0 = 0
Local1 = Package(Local0) { }
Debug = Local1
Return (0)
}
}

7
kernel/hal/x86_64/uACPI/tests/test-cases/eval-supports-plain-objects.asl Normal file
View File

@ -0,0 +1,7 @@
// Name: Eval supports plain objects
// Expect: str => This is a plain string, not a method
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (MAIN, "This is a plain string, not a method")
}

31
kernel/hal/x86_64/uACPI/tests/test-cases/event.asl Normal file
View File

@ -0,0 +1,31 @@
// Name: Event signal & wait
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, Serialized)
{
Event (EVET)
Local0 = 5
While (Local0--) {
Signal(EVET)
}
Local0 = 5
While (Local0--) {
Local1 = Wait(EVET, 0xFFFD + Local0)
If (Local1 != Zero) {
Return (Local1)
}
}
// This should fail
Local1 = Wait(EVET, Zero)
If (Local1 == Zero) {
Return (One)
}
Return (Zero)
}
}

48
kernel/hal/x86_64/uACPI/tests/test-cases/global-lock.asl Normal file
View File

@ -0,0 +1,48 @@
// Name: Global lock works
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (CHEK, 1, Serialized, 15)
{
If (Arg0 != 0) {
Debug = "Failed to acquire the global lock!"
Return (1)
}
Return (0)
}
Method (MAIN, 0, Serialized)
{
Local0 = 0
Debug = "Acquiring the lock manually!"
Local0 += CHEK(Acquire (_GL, 0xFFFF))
Local0 += CHEK(Acquire (_GL, 0xFFFF))
Local0 += CHEK(Acquire (_GL, 0xFFFF))
Local0 += CHEK(Acquire (_GL, 0xFFFF))
Debug = "Doing a field write..."
OperationRegion(NVSM, SystemMemory, 0x100000, 128)
Field (NVSM, AnyAcc, Lock, WriteAsZeros) {
FILD, 1,
}
FILD = 1
Debug = "Write done, we should still be holding the lock!"
Release(_GL)
Release(_GL)
Release(_GL)
Debug = "Should release NOW!"
Release(_GL)
// TODO? Would be nice to have some way to actually verify that a lock is held...
Return (Local0)
}
}

24
kernel/hal/x86_64/uACPI/tests/test-cases/hanging-while.asl Normal file
View File

@ -0,0 +1,24 @@
// Name: Infinite While loops eventually ends
// Expect: int => 1
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (LOOP, 0)
Method (HANG) {
LOOP = 1
While (LOOP++) { }
}
HANG()
Method (MAIN) {
Printf("Looped %o times before getting aborted", ToDecimalString(LOOP))
If (LOOP < 100) {
Return (0)
}
Return (1)
}
}

60
kernel/hal/x86_64/uACPI/tests/test-cases/increment-fields.asl Normal file
View File

@ -0,0 +1,60 @@
// Name: Increment And Decrement Fields & Indices
// Expect: int => 150
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (BROK, 2) {
Printf ("%o increment is broken", Arg0)
Return (Arg1)
}
Method (MAIN, 0, Serialized)
{
Local0 = Buffer { 1 }
Local1 = Package {
123, 22
}
Debug = Increment(Local0[0])
Debug = Decrement(Local1[0])
Local2 = Local1[1]
Debug = Increment(Local2)
OperationRegion(NVSM, SystemMemory, 0x100000, 128)
Field (NVSM, AnyAcc, NoLock, WriteAsZeros) {
FILD, 1,
}
FILD = 0
Debug = Increment(FILD)
// We get a 2 here but write back 0 because field is one bit
Local3 = Increment(FILD)
If (FILD != 0) {
Return (BROK("Field unit", 0xDEADBEEF))
}
Local4 = Increment(FILD)
If (FILD != 1) {
Return (BROK("Field unit", 0xBEEFDEAD))
}
If (DerefOf(Local2) != DerefOf(Local1[1])) {
Return (BROK("Buffer index", 0xCAFEBABE))
}
Return (
// 2
DerefOf(Local0[0]) +
// 122
DerefOf(Local1[0]) +
// 23
DerefOf(Local2) +
// 2
Local3 +
// 1
Local4
)
}
}

39
kernel/hal/x86_64/uACPI/tests/test-cases/indices-0.asl Normal file
View File

@ -0,0 +1,39 @@
// Name: Buffer Indices
// Expect: str => HfVXoWorld
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (FAIL, 2)
{
Printf("Invalid string %o, expected %o", Arg0, Arg1)
Return(1)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "HelloWorld"
Local0[3] = "X"
Local1 = "HelXoWorld"
If (Local0 != Local1) {
Return(FAIL(Local0, Local1))
}
Local2 = RefOf(Index(Local0, 2))
Local2 = "V"
Local1 = "HeVXoWorld"
If (Local0 != Local1) {
Return(FAIL(Local0, Local1))
}
CopyObject(Index(Local0, 1), Local2)
Local0[1] = 0x66
If (DerefOf(Local2) != 0x66) {
Return(1)
}
Return (Local0)
}
}

52
kernel/hal/x86_64/uACPI/tests/test-cases/indices-1.asl Normal file
View File

@ -0,0 +1,52 @@
// Name: Dump Package Contents
// Expect: str => { HelloWorld, 123, deadbeef, { some string, { ffffffffeeeeeeee, middle package }, cafebabe } }
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (DUMP, 1)
{
Local0 = 0
Local1 = "{ "
While (Local0 < SizeOf(Arg0)) {
// If package, invoke DUMP recursively
If (ObjectType(DerefOf(Arg0[Local0])) == 4) {
Fprintf(Local1, "%o, %o", Local1, DUMP(DerefOf(Arg0[Local0])))
Local0 += 1
Continue;
}
If (Local0 == 0) {
Local3 = ""
} Else {
Local3 = ", "
}
Fprintf(Local1, "%o%o%o", Local1, Local3, DerefOf(Arg0[Local0]))
Local0 += 1
}
Fprintf(Local1, "%o }", Local1)
Return(Local1)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = Package {
"HelloWorld",
0x123,
0xDEADBEEF,
Package {
"some string",
Package {
0xFFFFFFFFEEEEEEEE,
"middle package",
},
0xCAFEBABE,
},
}
Local1 = DUMP(Local0)
Return(Local1)
}
}

50
kernel/hal/x86_64/uACPI/tests/test-cases/indices-2.asl Normal file
View File

@ -0,0 +1,50 @@
// Name: Package Indices w/ References
// Expect: int => 1062815831
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1)
{
Local0 = Package {
1, 2, 3, "String"
}
Local1 = 0
Arg0[1] = RefOf(Local0)
Arg0[2] = RefOf(Local1)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = Package {
"HelloWorld",
0x123,
0xDEADBEEF,
Package {
"some string",
0xCAFEBABE
}
}
TEST(Local0)
Local1 = DerefOf(DerefOf(Local0[1])[3])
If (Local1 != "String") {
Printf("Invalid value at nested package %o", Local1)
Return (1)
}
Local0[2] = "WHY?"
Local2 = DerefOf(Local0[2])
// Why in little-endian ascii
Local3 = 1062815831
If (Local2 != Local3) {
Printf("Failed to implicit cast, expected %o, got %o", Local3, Local2)
Return (1)
}
Return (Local2)
}
}

22
kernel/hal/x86_64/uACPI/tests/test-cases/infinite-recursion.asl Normal file
View File

@ -0,0 +1,22 @@
// Name: Infinite recursion eventually ends
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (MAIN, 0xDEADBEEF)
Name (ITER, 0)
Method (HANG) {
ITER++
HANG()
}
HANG()
Printf("Recursed %o times before stopping", ToDecimalString(ITER))
If (ITER > 64) {
MAIN = 0
} Else {
Debug = "Recursion depth was too small"
}
}

12
kernel/hal/x86_64/uACPI/tests/test-cases/local0.asl Normal file
View File

@ -0,0 +1,12 @@
// Name: Return Integer Using Local0
// Expect: int => 0x123
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = 0x123
Debug = Local0
Return (Local0)
}
}

11
kernel/hal/x86_64/uACPI/tests/test-cases/local0_string.asl Normal file
View File

@ -0,0 +1,11 @@
// Name: Return String Using Local0
// Expect: str => hello world
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Debug = (Local0 = "hello world")
Return (Local0)
}
}

61
kernel/hal/x86_64/uACPI/tests/test-cases/method-calls.asl Normal file
View File

@ -0,0 +1,61 @@
// Name: Call methods with every ArgX
// Expect: int => 8
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method(TES7, 7) {
Local0 = Arg0 + Arg1 + Arg2 + Arg3 + Arg4 + Arg5 + Arg6
If (Local0 != (1 + 2 + 3 + 4 + 5 + 6 + 7)) { Return (Local0) }
Return (1)
}
Method(TES6, 6) {
Local0 = Arg0 + Arg1 + Arg2 + Arg3 + Arg4 + Arg5
If (Local0 != (1 + 2 + 3 + 4 + 5 + 6)) { Return (Local0) }
Return (1)
}
Method(TES5, 5) {
Local0 = Arg0 + Arg1 + Arg2 + Arg3 + Arg4
If (Local0 != (1 + 2 + 3 + 4 + 5)) { Return (Local0) }
Return (1)
}
Method(TES4, 4) {
Local0 = Arg0 + Arg1 + Arg2 + Arg3
If (Local0 != (1 + 2 + 3 + 4)) { Return (Local0) }
Return (1)
}
Method(TES3, 3) {
Local0 = Arg0 + Arg1 + Arg2
If (Local0 != (1 + 2 + 3)) { Return (Local0) }
Return (1)
}
Method(TES2, 2) {
Local0 = Arg0 + Arg1
If (Local0 != (1 + 2)) { Return (Local0) }
Return (1)
}
Method(TES1, 1) {
Local0 = Arg0
If (Local0 != (1 + 2)) { Return (Local0) }
Return (1)
}
Method(TES0, 0) { Return (1) }
Method (MAIN)
{
Return(TES7(1, 2, 3, 4, 5, 6, 7) +
TES6(1, 2, 3, 4, 5, 6) +
TES5(1, 2, 3, 4, 5) +
TES4(1, 2, 3, 4) +
TES3(1, 2, 3) +
TES2(1, 2) +
TES1(1) +
TES0())
}
}

34
kernel/hal/x86_64/uACPI/tests/test-cases/multilevel_ref.asl Normal file
View File

@ -0,0 +1,34 @@
// Name: Multilevel reference w/ Increment
// Expect: int => 0xDEAD0005
DefinitionBlock ("", "DSDT", 1, "uTTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = 0xDEAD0000
Local1 = RefOf(Local0)
Debug = Local1
Local2 = RefOf(Local1)
Debug = Local2
Local3 = RefOf(Local2)
Debug = Local3
Local4 = RefOf(Local3)
Debug = Local4
Local5 = RefOf(Local4)
Debug = Local5
Debug = Increment(Local1)
Debug = Increment(Local2)
Debug = Increment(Local3)
Debug = Increment(Local4)
Debug = Increment(Local5)
Debug = Local0
Return (DerefOf(Local5))
}
}

55
kernel/hal/x86_64/uACPI/tests/test-cases/mutex-1.asl Normal file
View File

@ -0,0 +1,55 @@
// Name: Automatic mutex release
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (CHEK, 1, Serialized, 15)
{
If (Arg0 != 0) {
Debug = "Failed to acquire mutex!"
Return (1)
}
Return (0)
}
Method (MAIN, 0, Serialized)
{
Mutex(MUT0, 0)
Mutex(MUT1, 1)
Mutex(MUT2, 2)
Mutex(MUT3, 3)
Mutex(MUT4, 4)
Mutex(MUT5, 5)
Mutex(MUT6, 6)
Mutex(MUT7, 7)
Mutex(MUT8, 8)
Mutex(MUT9, 9)
Mutex(MUTA, 10)
Mutex(MUTB, 11)
Mutex(MUTC, 12)
Mutex(MUTD, 13)
Mutex(MUTE, 14)
Mutex(MUTF, 15)
Local0 = 0
Local0 += CHEK(Acquire(MUT0, 0))
Local0 += CHEK(Acquire(MUT1, 0))
Local0 += CHEK(Acquire(MUT2, 0))
Local0 += CHEK(Acquire(MUT3, 0))
Local0 += CHEK(Acquire(MUT4, 0))
Local0 += CHEK(Acquire(MUT5, 0))
Local0 += CHEK(Acquire(MUT6, 0))
Local0 += CHEK(Acquire(MUT7, 0))
Local0 += CHEK(Acquire(MUT8, 0))
Local0 += CHEK(Acquire(MUT9, 0))
Local0 += CHEK(Acquire(MUTA, 0))
Local0 += CHEK(Acquire(MUTB, 0))
Local0 += CHEK(Acquire(MUTC, 0))
Local0 += CHEK(Acquire(MUTD, 0xFFFE))
Local0 += CHEK(Acquire(MUTE, 0xFFFD))
Local0 += CHEK(Acquire(MUTF, 0xFFFF))
Return (Local0)
}
}

64
kernel/hal/x86_64/uACPI/tests/test-cases/mutex-2.asl Normal file
View File

@ -0,0 +1,64 @@
// Name: Out of order mutex release
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (CHEK, 1, Serialized, 15)
{
If (Arg0 != 0) {
Debug = "Failed to acquire mutex!"
Return (1)
}
Return (0)
}
Method (MAIN, 0, Serialized)
{
Mutex(MUT0)
Mutex(MUT1)
Mutex(MUT2)
Mutex(MUT3)
Mutex(MUT4)
Mutex(MUT5)
Mutex(MUT6)
Mutex(MUT7)
Mutex(MUT8)
Mutex(MUT9)
Mutex(MUTA)
Mutex(MUTB)
Mutex(MUTC)
Mutex(MUTD)
Mutex(MUTE)
Mutex(MUTF)
Local0 = 0
Local0 += CHEK(Acquire(MUT0, 0))
Local0 += CHEK(Acquire(MUT1, 0))
Local0 += CHEK(Acquire(MUT2, 0))
Local0 += CHEK(Acquire(MUT3, 0))
Local0 += CHEK(Acquire(MUT4, 0))
Local0 += CHEK(Acquire(MUT5, 0))
Local0 += CHEK(Acquire(MUT6, 0))
Local0 += CHEK(Acquire(MUT7, 0))
Local0 += CHEK(Acquire(MUT8, 0))
Local0 += CHEK(Acquire(MUT9, 0xF))
Local0 += CHEK(Acquire(MUTA, 0))
Local0 += CHEK(Acquire(MUTB, 3))
Local0 += CHEK(Acquire(MUTC, 123))
Local0 += CHEK(Acquire(MUTD, 0xFFFE))
Local0 += CHEK(Acquire(MUTE, 0xFFFD))
Local0 += CHEK(Acquire(MUTF, 0xFFFF))
Release(MUTA)
Release(MUT9)
Release(MUTC)
Release(MUT1)
Release(MUT7)
Release(MUTE)
Release(MUTD)
// The rest are released automatically when we exit the outermost method
Return (Local0)
}
}

37
kernel/hal/x86_64/uACPI/tests/test-cases/mutex-3.asl Normal file
View File

@ -0,0 +1,37 @@
// Name: Recursive mutex
// Expect: int => 253
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (CHEK, 1, Serialized, 15)
{
If (Arg0 != 0) {
Debug = "Failed to acquire mutex!"
Return (1)
}
Return (0)
}
Mutex (MUTX)
Method (ACQ, 1, Serialized) {
CHEK(Acquire(MUTX, 0xFFFF))
Local0 = 0
If (Arg0 < 22) {
Local0 += Arg0 + ACQ(Arg0 + 1)
} Else {
Local0 += Arg0
}
Release(MUTX)
Return (Local0)
}
Method (MAIN, 0, Serialized)
{
Return (ACQ(0))
}
}

25
kernel/hal/x86_64/uACPI/tests/test-cases/notifications-and-requests.asl Normal file
View File

@ -0,0 +1,25 @@
// Name: Notifications & Requests
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (FATL, 1)
{
Fatal(0xFF, 0xDEADBEEF, ToInteger(Arg0))
}
Device (PSP) {
Name (_HID, "ACPI0000")
}
Method (MAIN, 0, NotSerialized)
{
Breakpoint
FATL("0xCAFEBABEC0DEDEAD")
Breakpoint
Notify(PSP, 0x10)
Return (0)
}
}

80
kernel/hal/x86_64/uACPI/tests/test-cases/object-api-works.asl Normal file
View File

@ -0,0 +1,80 @@
// Name: Public API for object mutation works
// Expect: str => check-object-api-works
DefinitionBlock ("x.aml", "SSDT", 1, "uTEST", "APITESTS", 0xF0F0F0F0)
{
Method (MAIN) {
// Skip for non-uacpi test runners
Return ("check-object-api-works")
}
/*
* Arg0 -> Expected case
* Arg1 -> The actual value
* Return -> Ones on succeess, Zero on failure
*/
Method (CHEK, 2) {
Switch (Arg0) {
Case (1) {
Local0 = 0xDEADBEEF
Break
}
Case (2) {
Local0 = "Hello World"
Break
}
Case (3) {
Local0 = "TEST"
/*
* Arg1 is expected to be a reference to a string XXXX, store
* into it here to invoke implicit case semantics.
*/
Arg1 = Local0
Break
}
Case (4) {
Local0 = Buffer { 0xDE, 0xAD, 0xBE, 0xEF }
Break
}
Case (5) {
If (ObjectType(Arg1) != 4) {
Printf("Expected a Package, got %o", Arg1)
Return (Zero)
}
If (SizeOf(Arg1) != 3) {
Printf("Expected a Package of 3 elements, got %o", SizeOf(Arg1))
Return (Zero)
}
Local0 = Package {
"First Element",
2,
Buffer { 1, 2, 3 },
}
Local1 = 0
While (Local1 < 3) {
If (DerefOf(Local0[Local1]) != DerefOf(Arg1[Local1])) {
Printf("Expected %o, got %o!", DerefOf(Local0[Local1]), DerefOf(Arg1[Local1]))
Return (Zero)
}
Printf("Object %o OK", Local1)
Local1++
}
Return (Ones)
}
}
If (Local0 != Arg1) {
Printf("Expected '%o', got '%o'!", Local0, Arg1)
Return (Zero)
}
Printf("Comparison %o OK", Arg0)
Return (Ones)
}
}

81
kernel/hal/x86_64/uACPI/tests/test-cases/osi.asl Normal file
View File

@ -0,0 +1,81 @@
// Name: _OSI works correctly
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (CHEK, 2) {
Local0 = _OSI(Arg0)
If (Local0 != Arg1) {
Printf("_OSI(%o) failed (expected %o, got %o)", Arg0, Arg1, Local0)
Return (1)
}
Return (0)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = 0
If (!CondRefOf(_OSI)) {
Debug = "No _OSI method!"
Return (1111111)
}
Local0 += CHEK("Windows 2000", Ones)
Local0 += CHEK("Windows 2001", Ones)
Local0 += CHEK("Windows 2001 SP1", Ones)
Local0 += CHEK("Windows 2001.1", Ones)
Local0 += CHEK("Windows 2001 SP2", Ones)
Local0 += CHEK("Windows 2001.1 SP1", Ones)
Local0 += CHEK("Windows 2006.1", Ones)
Local0 += CHEK("Windows 2006 SP1", Ones)
Local0 += CHEK("Windows 2006 SP2", Ones)
Local0 += CHEK("Windows 2009", Ones)
Local0 += CHEK("Windows 2012", Ones)
Local0 += CHEK("Windows 2013", Ones)
Local0 += CHEK("Windows 2015", Ones)
Local0 += CHEK("Windows 2016", Ones)
Local0 += CHEK("Windows 2017", Ones)
Local0 += CHEK("Windows 2017.2", Ones)
Local0 += CHEK("Windows 2018", Ones)
Local0 += CHEK("Windows 2018.2", Ones)
Local0 += CHEK("Windows 2019", Ones)
// ACPICA acpiexec
If (_OSI("AnotherTestString")) {
// do nothing
Debug = "ACPICA acpiexec detected"
} ElseIf (_OSI("TestRunner")) {
Debug = "uACPI test runner detected"
// These are only enabled in uACPI test runner
Local0 += CHEK("3.0 Thermal Model", Ones)
Local0 += CHEK("Module Device", Ones)
// Don't check these in ACPICA, it might be too old to have these
Local0 += CHEK("Windows 2020", Ones)
Local0 += CHEK("Windows 2021", Ones)
Local0 += CHEK("Windows 2022", Ones)
} Else {
Debug = "Neither uACPI nor ACPICA were detected, aborting test"
Return (123321)
}
// This is removed in both uACPI and ACPICA test runners
Local0 += CHEK("Windows 2006", Zero)
Local0 += CHEK("Extended Address Space Descriptor", Ones)
Local0 += CHEK("Processor Aggregator Device", Zero)
Local0 += CHEK("3.0 _SCP Extensions", Zero)
Local0 += CHEK("Processor Device", Zero)
Local0 += CHEK("", Zero)
Local0 += CHEK("Windows 99999", Zero)
Local0 += CHEK("Windows 2014", Zero)
Local0 += CHEK("Linux", Zero)
Return (Local0)
}
}

40
kernel/hal/x86_64/uACPI/tests/test-cases/read-from-deleted-field.asl Normal file
View File

@ -0,0 +1,40 @@
// Name: IO from deleted fields doesn't crash
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
External(MAIN)
If (!CondRefOf(MAIN)) {
Name (MAIN, Ones)
/*
* Load ourselves again, we won't enter this branch a second time.
* We expect this LoadTable call to fail because of the invalid
* field store.
*/
MAIN = LoadTable("DSDT", "uTEST", "TESTTABL", "", "", 0)
Return (0)
}
Method (TEST) {
OperationRegion(MYRE, SystemMemory, 0, 128)
Field (MYRE, AnyAcc, NoLock) {
FILD, 32
}
FILD = 1
Return (RefOf(FILD))
}
Name (X, "")
/*
* Get a dangling field object and make X be this field.
* Then attempt to perform a read from it.
*/
Local0 = TEST()
CopyObject(DerefOf(Local0), X)
Debug = X
}

14
kernel/hal/x86_64/uACPI/tests/test-cases/ref_modify_indirect.asl Normal file
View File

@ -0,0 +1,14 @@
// Name: Modify Local0 Using RefOf Local1
// Expect: int => 0x124
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = RefOf(Local1)
Local0 = 0x123
Debug = Local0
Debug = Local1
Return(Local1++)
}
}

19
kernel/hal/x86_64/uACPI/tests/test-cases/ref_modify_via_method_call.asl Normal file
View File

@ -0,0 +1,19 @@
// Name: Modify Local0 Using Arg0
// Expect: int => 124
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Local0 = RefOf(Arg0)
Local0 = 123
Arg0++
}
Method (MAIN, 0, NotSerialized)
{
Local0 = 200
TEST(RefOf(Local0))
Return (Local0)
}
}

17
kernel/hal/x86_64/uACPI/tests/test-cases/references-0.asl Normal file
View File

@ -0,0 +1,17 @@
// Name: Call-by-value w/ Store() doesn't modify Local
// Expect: str => MyString
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Arg0 = 0xDEADBEEF
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyString"
TEST(Local0)
Return (Local0)
}
}

17
kernel/hal/x86_64/uACPI/tests/test-cases/references-1.asl Normal file
View File

@ -0,0 +1,17 @@
// Name: Call-by-value w/ CopyObject() doesn't modify Local
// Expect: str => MyString
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
CopyObject(0xDEADBEEF, Arg0)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyString"
TEST(Local0)
Return (Local0)
}
}

24
kernel/hal/x86_64/uACPI/tests/test-cases/references-10.asl Normal file
View File

@ -0,0 +1,24 @@
// Name: Recursively modify ArgX
// Expect: int => 0x100A
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 2, NotSerialized)
{
Local0 = RefOf(Arg0)
Local0++
Debug = Arg1
Debug = DerefOf(Local0)
If (Arg1--) {
TEST(RefOf(Arg0), Arg1)
}
}
Method (MAIN, 0, NotSerialized)
{
Local0 = 0x1000
TEST(RefOf(Local0), 10)
Return (Local0)
}
}

23
kernel/hal/x86_64/uACPI/tests/test-cases/references-3.asl Normal file
View File

@ -0,0 +1,23 @@
// Name: Call-by-value w/ Store() modifies strings through a reference
// Expect: str => WHY?
// NOTE:
// This test seems bogus but it's actually corrrect, it produces
// the same output on NT.
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Local0 = RefOf(Arg0)
// WHY? in little-endian ASCII
Local0 = 0x3F594857
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyST"
TEST(Local0)
Return (Local0)
}
}

18
kernel/hal/x86_64/uACPI/tests/test-cases/references-4.asl Normal file
View File

@ -0,0 +1,18 @@
// Name: Call-by-value w/ Store() does NOT modify integers even through a reference
// Expect: int => 0x123
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Local0 = RefOf(Arg0)
Local0 = 0xDEADBEEF
}
Method (MAIN, 0, NotSerialized)
{
Local0 = 0x123
TEST(Local0)
Return (Local0)
}
}

21
kernel/hal/x86_64/uACPI/tests/test-cases/references-5.asl Normal file
View File

@ -0,0 +1,21 @@
// Name: LocalX reference is rebindable via CopyObject
// Expect: str => Modified
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Local0 = RefOf(Arg0)
Local0 = "Modified String"
CopyObject("Wrong String", Local0)
Local0 = 0xDEADBEEF
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyString"
TEST(Local0)
Return (Local0)
}
}

18
kernel/hal/x86_64/uACPI/tests/test-cases/references-6.asl Normal file
View File

@ -0,0 +1,18 @@
// Name: ArgX reference is not rebindable via CopyObject
// Expect: int => 0xDEADBEEF
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
CopyObject(0xDEADC0DE, Arg0)
CopyObject(0xDEADBEEF, Arg0)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyString"
TEST(RefOf(Local0))
Return (Local0)
}
}

25
kernel/hal/x86_64/uACPI/tests/test-cases/references-7.asl Normal file
View File

@ -0,0 +1,25 @@
// Name: ArgX non-reference is rebindable
// Expect: str => MyString
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TES0, 1, NotSerialized)
{
CopyObject("Hello World", Arg0)
Debug = Arg0
}
Method (TES1, 1, NotSerialized)
{
Arg0 = 0x123
Debug = Arg0
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyString"
TES0(Local0)
TES1(Local0)
Return(Local0)
}
}

18
kernel/hal/x86_64/uACPI/tests/test-cases/references-8.asl Normal file
View File

@ -0,0 +1,18 @@
// Name: ArgX reference is not rebindable via Store
// Expect: int => 0xDEADBEEF
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Store(0xDEADC0DE, Arg0)
Store(0xDEADBEEF, Arg0)
}
Method (MAIN, 0, NotSerialized)
{
Local0 = "MyString"
TEST(RefOf(Local0))
Return (Local0)
}
}

18
kernel/hal/x86_64/uACPI/tests/test-cases/references-9.asl Normal file
View File

@ -0,0 +1,18 @@
// Name: Modification via LocalX reference implict-casts (string->int64)
// Expect: int => 0x676E6F6C79726576
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (TEST, 1, NotSerialized)
{
Local0 = RefOf(Arg0)
Local0 = "verylongstringbiggerthanint"
}
Method (MAIN, 0, NotSerialized)
{
Local0 = 0xDEADC0DEDEADBEEF
TEST(RefOf(Local0))
Return (Local0)
}
}

147
kernel/hal/x86_64/uACPI/tests/test-cases/reg-devices.asl Normal file
View File

@ -0,0 +1,147 @@
// Name: _REG gets called correctly
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (RET, 0)
Device (PCI0) {
Name (_HID, "PNP0000")
Method (_CID) {
Local0 = Package {
"idk",
0x000A2E4F,
"badid",
0x02002E4F,
0x030FD041,
0x130FD041,
0x120FD041,
// PCI Express root bridge
"PNP0A08"
}
Return (Local0)
}
Name (_SEG, 0x1)
Name (_BBN, 0x10)
Device (HPET) {
Name (_HID, "PNP0103")
OperationRegion(LOLX, SystemMemory, 0xDEADBEEF, 123)
Method (_REG, 2) {
Debug = "HPET._REG shouldn't have been called"
RET += 1
}
}
Name (STAT, 0)
Device (UHCI) {
Name (_ADR, 0x0001000F)
Method (TEST, 1, Serialized) {
Method (_REG, 2, Serialized) {
Printf("PCIR _REG(%o, %o) called", Arg0, Arg1)
If (Arg0 != 2) {
Printf("Invalid space value %o", Arg0)
RET += 1
}
Switch (Arg1) {
Case (0) {
If (STAT != 1) {
Debug = "Trying to _REG(disconnect) before _REG(connect)"
RET += 1
Break
}
STAT += 1
Break
}
Case (1) {
If (STAT != 0) {
Debug = "Trying to run _REG(connect) twice"
RET += 1
Break
}
STAT += 1
Break
}
}
}
OperationRegion(PCIR, PCI_Config, 0x00, Arg0)
Field (PCIR, AnyAcc, NoLock) {
REG0, 8
}
If (STAT != 1) {
Debug = "No one ever called _REG on PCIR, giving up"
RET += 1
Return ()
}
REG0 = 123
}
}
}
Device (PCI1) {
Name (STAT, 0)
// PCI root bus
Name (_HID, "PNP0A03")
Device (XHCI) {
Name (_ADR, 0x00030002)
OperationRegion(HREG, PCI_Config, 0x04, 0xF0)
Field (HREG, AnyAcc, NoLock) {
REG2, 8
}
// This can only be called after loading the namespace
Method (_REG, 2) {
Printf("HREG _REG(%o, %o) called", Arg0, Arg1)
If (Arg0 != 2) {
Printf("Invalid space value %o", Arg0)
RET += 1
}
If (Arg1 != 1 || STAT != 0) {
Printf("Invalid Arg1 (%o) for state %o", Arg1, STAT)
RET += 1
}
STAT += 1
}
Method (WRIT, 1) {
REG2 = Arg0
Return (Arg0)
}
}
}
Method (MAIN) {
\PCI0.UHCI.TEST(0xFF)
Local0 = 1
If (\PCI1.STAT == 1) {
Local0 -= \PCI1.XHCI.WRIT(1)
} Else {
Debug = "PCI1.XHCI._REG was never called!"
}
Return (RET + Local0)
}
}

15
kernel/hal/x86_64/uACPI/tests/test-cases/return0_indirect.asl Normal file
View File

@ -0,0 +1,15 @@
// Name: Return Integer 0 (Indirect)
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (HELP, 0, NotSerialized)
{
Return (0)
}
Method (MAIN, 0, NotSerialized)
{
Return (HELP())
}
}

32
kernel/hal/x86_64/uACPI/tests/test-cases/return1_using_ifs.asl Normal file
View File

@ -0,0 +1,32 @@
// Name: Return Integer 1 Using Ifs
// Expect: int => 1
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (GET0, 1, NotSerialized)
{
Debug = "GET0 called"
Return(Arg0)
}
Method (MAIN, 0, NotSerialized)
{
If (GET0(0)) {
Debug = "We shouldn't be here..."
} Else {
Local0 = 0
If (GET0(1)) {
Debug = "Branch worked"
Local0 = 1
} Else {
Debug = "Shouldn't see this either"
Local0 = 2
}
Return(Local0)
}
Return (3)
}
}

20
kernel/hal/x86_64/uACPI/tests/test-cases/return_0xdead_double_indirect.asl Normal file
View File

@ -0,0 +1,20 @@
// Name: Return Integer 0xDEAD (Double Indirect)
// Expect: int => 0xDEAD
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (HELP, 0, NotSerialized)
{
Return (0xDEAD)
}
Method (INDI, 0, NotSerialized)
{
Return (HELP())
}
Method (MAIN, 0, NotSerialized)
{
Return (INDI())
}
}

10
kernel/hal/x86_64/uACPI/tests/test-cases/return_byte.asl Normal file
View File

@ -0,0 +1,10 @@
// Name: Return Integer (Byte 0xCA)
// Expect: int => 0xCA
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Return (0xCA)
}
}

10
kernel/hal/x86_64/uACPI/tests/test-cases/return_dword.asl Normal file
View File

@ -0,0 +1,10 @@
// Name: Return Integer (DWord 0xCAFEBABE)
// Expect: int => 0xCAFEBABE
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Return (0xCAFEBABE)
}
}

10
kernel/hal/x86_64/uACPI/tests/test-cases/return_qword.asl Normal file
View File

@ -0,0 +1,10 @@
// Name: Return Integer (QWord 0xCAFEBABEDEADC0DE)
// Expect: int => 0xCAFEBABEDEADC0DE
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Return (0xCAFEBABEDEADC0DE)
}
}

10
kernel/hal/x86_64/uACPI/tests/test-cases/return_word.asl Normal file
View File

@ -0,0 +1,10 @@
// Name: Return Integer (Word 0xCAFE)
// Expect: int => 0xCAFE
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Return (0xCAFE)
}
}

32
kernel/hal/x86_64/uACPI/tests/test-cases/scope.asl Normal file
View File

@ -0,0 +1,32 @@
// Name: Scopes and undefined references
// Expect: int => 13
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name (MAIN, 0)
Scope (\PATH.THAT.DOES.NOT.EXIS.T) {
Debug = "Why are we here"
MAIN += 1
}
Scope (\_SB) {
MAIN += 3
Scope (^ANOT.HER) {
MAIN += 4
}
Scope (\_GPE) {
MAIN += 10
Scope (PATH) {
MAIN += 200
}
}
Scope (FAIL.TOO) {
MAIN += 300
}
}
}

50
kernel/hal/x86_64/uACPI/tests/test-cases/sleep.asl Normal file
View File

@ -0,0 +1,50 @@
// Name: Sleep & Stall
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (CHEK, 4)
{
Local0 = Arg2 - Arg1
If (Local0 < Arg3) {
Printf("%o finished too soon, elapsed %o, expected at least %o",
Arg0, ToDecimalString(Local0), ToDecimalString(Arg3))
Return (1)
}
Return (0)
}
Method (STAL, 1) {
Local1 = 0
While (Local1 < Arg0) {
Stall(100)
Local1 += 1
}
}
Method (MAIN, 0, Serialized)
{
Local0 = Timer
// Stall for 10 * 100 microseconds (aka 1ms)
STAL(10)
If (CHEK("Stall", Local0, Timer, 10000) != 0) {
Return (1)
}
Local0 = Timer
// Sleep for 2ms
Sleep(2)
If (CHEK("Sleep", Local0, Timer, 20000) != 0) {
Return (1)
}
Return (0)
}
}

26
kernel/hal/x86_64/uACPI/tests/test-cases/store-copies-buffer.asl Normal file
View File

@ -0,0 +1,26 @@
// Name: Store Copies The Buffer
// Expect: str => Hello
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MODF, 0, NotSerialized)
{
Local1 = Store("Hello", Local0)
Return (Local1)
}
Method (MAIN, 0, NotSerialized)
{
Local1 = Store(MODF(), Local0)
// Modify the string at Local1
Local2 = RefOf(Local1)
Local2 = "Goodbye"
Debug = Local0
Debug = Local1
// Local0 should still have the same value
Return(Local0)
}
}

61
kernel/hal/x86_64/uACPI/tests/test-cases/table-loading-0.asl Normal file
View File

@ -0,0 +1,61 @@
// Name: Load tables from buffers
// Expect: str => Hello World 123
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, Serialized)
{
Name (WRLD, "World")
/*
* Method (PRT0, 0, NotSerialized)
* {
* Return(Concatenate("Hello ", \MAIN.WRLD))
* }
*/
External(\PRT0, MethodObj)
Name (TABL, Buffer {
0x53,0x53,0x44,0x54,0x40,0x00,0x00,0x00, /* 00000000 "SSDT@..." */
0x02,0x86,0x75,0x54,0x45,0x53,0x54,0x00, /* 00000008 "..uTEST." */
0x54,0x45,0x53,0x54,0x54,0x41,0x42,0x4C, /* 00000010 "TESTTAB0" */
0xF0,0xF0,0xF0,0xF0,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x31,0x03,0x22,0x20,0x14,0x1B,0x50,0x52, /* 00000020 "1." ..PR" */
0x54,0x30,0x00,0xA4,0x73,0x0D,0x48,0x65, /* 00000028 "T0..s.He" */
0x6C,0x6C,0x6F,0x20,0x00,0x5C,0x2E,0x4D, /* 00000030 "llo .\.M" */
0x41,0x49,0x4E,0x57,0x52,0x4C,0x44,0x00 /* 00000038 "AINWRLD." */
})
If (!Load(TABL)) {
Return ("Table 0 load failed")
}
/*
* Name (O123, "123")
*
* Method (PRT1, 2, NotSerialized)
* {
* Return(Concatenate(Concatenate(Arg0, " "), Arg1))
* }
*/
External(\PRT1, MethodObj)
External(\O123, StrObj)
Name (TAB1, Buffer {
0x53,0x53,0x44,0x54,0x3F,0x00,0x00,0x00, /* 00000000 "SSDT?..." */
0x02,0x97,0x75,0x54,0x45,0x53,0x54,0x00, /* 00000008 "..uTEST." */
0x54,0x45,0x53,0x54,0x54,0x41,0x42,0x4C, /* 00000010 "TESTTAB1" */
0xF0,0xF0,0xF0,0xF0,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x31,0x03,0x22,0x20,0x08,0x4F,0x31,0x32, /* 00000020 "1." .O12" */
0x33,0x0D,0x31,0x32,0x33,0x00,0x14,0x10, /* 00000028 "3.123..." */
0x50,0x52,0x54,0x31,0x02,0xA4,0x73,0x73, /* 00000030 "PRT1..ss" */
0x68,0x0D,0x20,0x00,0x00,0x69,0x00 /* 00000038 "h. ..i." */
})
Load(TAB1, Local1)
If (!Local1) {
Return ("Table 1 load failed")
}
Local0 = PRT0()
Return (PRT1(Local0, O123))
}
}

76
kernel/hal/x86_64/uACPI/tests/test-cases/table-loading-1.asl Normal file
View File

@ -0,0 +1,76 @@
// Name: Load tables from opregions & fields
// Expect: str => Hello World 123
DefinitionBlock ("", "SSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, Serialized)
{
Name (WRLD, "World")
/*
* Method (PRT0, 0, NotSerialized)
* {
* Return(Concatenate("Hello ", \MAIN.WRLD))
* }
*/
External(\PRT0, MethodObj)
Name (TAB0, Buffer {
0x53,0x53,0x44,0x54,0x40,0x00,0x00,0x00, /* 00000000 "SSDT@..." */
0x02,0x86,0x75,0x54,0x45,0x53,0x54,0x00, /* 00000008 "..uTEST." */
0x54,0x45,0x53,0x54,0x54,0x41,0x42,0x4C, /* 00000010 "TESTTAB0" */
0xF0,0xF0,0xF0,0xF0,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x31,0x03,0x22,0x20,0x14,0x1B,0x50,0x52, /* 00000020 "1." ..PR" */
0x54,0x30,0x00,0xA4,0x73,0x0D,0x48,0x65, /* 00000028 "T0..s.He" */
0x6C,0x6C,0x6F,0x20,0x00,0x5C,0x2E,0x4D, /* 00000030 "llo .\.M" */
0x41,0x49,0x4E,0x57,0x52,0x4C,0x44,0x00 /* 00000038 "AINWRLD." */
})
OperationRegion(TABR, SystemMemory, 0xDEADBEE0, SizeOf(TAB0))
Field (TABR, WordAcc, NoLock, WriteAsOnes) {
COPY, 512,
}
COPY = TAB0
Load(TABR, Local0)
If (!Local0) {
Return ("Table 0 load failed")
}
/*
* Name (O123, "123")
*
* Method (PRT1, 2, NotSerialized)
* {
* Return(Concatenate(Concatenate(Arg0, " "), Arg1))
* }
*/
External(\PRT1, MethodObj)
External(\O123, StrObj)
Name (TAB1, Buffer {
0x53,0x53,0x44,0x54,0x3F,0x00,0x00,0x00, /* 00000000 "SSDT?..." */
0x02,0x97,0x75,0x54,0x45,0x53,0x54,0x00, /* 00000008 "..uTEST." */
0x54,0x45,0x53,0x54,0x54,0x41,0x42,0x4C, /* 00000010 "TESTTAB1" */
0xF0,0xF0,0xF0,0xF0,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x31,0x03,0x22,0x20,0x08,0x4F,0x31,0x32, /* 00000020 "1." .O12" */
0x33,0x0D,0x31,0x32,0x33,0x00,0x14,0x10, /* 00000028 "3.123..." */
0x50,0x52,0x54,0x31,0x02,0xA4,0x73,0x73, /* 00000030 "PRT1..ss" */
0x68,0x0D,0x20,0x00,0x00,0x69,0x00,0x00 /* 00000038 "h. ..i." */
})
OperationRegion(TABX, SystemMemory, 0xCAFEBAB0, SizeOf(TAB1))
Field (TABX, DWordAcc, NoLock, Preserve) {
BLOB, 512,
}
// Copy the table into the operation region
BLOB = TAB1
Load(BLOB, Local1)
If (!Local1) {
Return ("Table 1 load failed")
}
Local0 = PRT0()
Return (PRT1(Local0, O123))
}
Debug = MAIN()
}

113
kernel/hal/x86_64/uACPI/tests/test-cases/table-loading-2.asl Normal file
View File

@ -0,0 +1,113 @@
// Name: Recursive table loads
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
// Number of started table loads
Name (NUMB, 0)
// Number of finished table loads
Name (NUMA, 0)
/*
* DefinitionBlock ("", "SSDT", 1, "uTEST", "TESTTABL", 0xF0F0F0F0)
* {
* External(NUMA, IntObj)
* External(NUMB, IntObj)
* External(ITEM, IntObj)
* External(TABL, IntObj)
*
* // Recursively start 10 table loads
* If (NUMB < 10) {
* // Create an ITEM here to prove to the caller that we got invoked
* If (!CondRefOf(ITEM)) {
* Name (ITEM, 123)
* }
*
* NUMB += 1
* Local0 = Load(TABL)
*
* // The last load is expected to fail, everything before should succeed
* If (!Local0) {
* If (NUMB != 10) {
* NUMA = 0xDEADBEEF
* Printf("Table load %o failed", NUMB)
* }
* } Else {
* NUMA += 1
* }
*
*
* // Return something bogus here to make sure the return value isn't
* // propagated to the caller of Load.
* Return (Package { 1, 2 ,3})
* }
*
* // We're the last table load, do something naughty to cause an error
* Local0 = Package { 1 }
* Local1 = RefOf(Local0)
*
* // This code specifically attempts to perform a bogus implicit cast
* Local1 = "Hello World"
* }
*/
Name (TABL, Buffer {
0x53, 0x53, 0x44, 0x54, 0xdc, 0x00, 0x00, 0x00,
0x01, 0x33, 0x75, 0x54, 0x45, 0x53, 0x54, 0x00,
0x54, 0x45, 0x53, 0x54, 0x54, 0x41, 0x42, 0x4c,
0xf0, 0xf0, 0xf0, 0xf0, 0x49, 0x4e, 0x54, 0x4c,
0x28, 0x06, 0x23, 0x20, 0xa0, 0x22, 0x00, 0x15,
0x5c, 0x4e, 0x55, 0x4d, 0x41, 0x01, 0x00, 0x15,
0x5c, 0x4e, 0x55, 0x4d, 0x42, 0x01, 0x00, 0x15,
0x5c, 0x49, 0x54, 0x45, 0x4d, 0x01, 0x00, 0x15,
0x5c, 0x54, 0x41, 0x42, 0x4c, 0x01, 0x00, 0xa0,
0x4b, 0x07, 0x95, 0x4e, 0x55, 0x4d, 0x42, 0x0a,
0x0a, 0xa0, 0x10, 0x92, 0x5b, 0x12, 0x49, 0x54,
0x45, 0x4d, 0x00, 0x08, 0x49, 0x54, 0x45, 0x4d,
0x0a, 0x7b, 0x72, 0x4e, 0x55, 0x4d, 0x42, 0x01,
0x4e, 0x55, 0x4d, 0x42, 0x70, 0x5b, 0x20, 0x54,
0x41, 0x42, 0x4c, 0x00, 0x60, 0xa0, 0x38, 0x92,
0x60, 0xa0, 0x34, 0x92, 0x93, 0x4e, 0x55, 0x4d,
0x42, 0x0a, 0x0a, 0x70, 0x0c, 0xef, 0xbe, 0xad,
0xde, 0x4e, 0x55, 0x4d, 0x41, 0x70, 0x73, 0x73,
0x0d, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6c,
0x6f, 0x61, 0x64, 0x20, 0x00, 0x4e, 0x55, 0x4d,
0x42, 0x00, 0x0d, 0x20, 0x66, 0x61, 0x69, 0x6c,
0x65, 0x64, 0x00, 0x00, 0x5b, 0x31, 0xa1, 0x0b,
0x72, 0x4e, 0x55, 0x4d, 0x41, 0x01, 0x4e, 0x55,
0x4d, 0x41, 0xa4, 0x12, 0x07, 0x03, 0x01, 0x0a,
0x02, 0x0a, 0x03, 0x70, 0x12, 0x03, 0x01, 0x01,
0x60, 0x70, 0x71, 0x60, 0x61, 0x70, 0x0d, 0x48,
0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72,
0x6c, 0x64, 0x00, 0x61
})
Method (MAIN, 0, Serialized)
{
Load(TABL, Local0)
Printf("Recursive loads finished!")
If (!Local0) {
Printf("Table load failed!")
Return (0xCAFEBABE)
}
External(ITEM, IntObj)
If (ITEM != 123) {
Printf("ITEM has incorrect value %o", ITEM)
Return (0xDEADBEEF)
}
If (NUMB != 10) {
Printf("Invalid NUMB value %o", ToDecimalString(NUMB))
Return (0xEEFFAABB)
}
If (NUMA != 9) {
Printf("Invalid NUMA value %o", ToDecimalString(NUMA))
Return (0x11223344)
}
Return (0)
}
}

106
kernel/hal/x86_64/uACPI/tests/test-cases/table-loading-3.asl Normal file
View File

@ -0,0 +1,106 @@
// Name: Recursive table loads with LoadTable
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
External(ITEM, IntObj)
External(NUMB, IntObj)
External(NUMA, IntObj)
External(VISI, IntObj)
// All dynamic loads branch into here
If (CondRefOf(ITEM)) {
// Recursively start 10 table loads
If (NUMB < 10) {
NUMB += 1
Local0 = NUMB
If (NUMB == 3) {
Local0 = LoadTable("DSDT", "uTEST", "", "", "PARA", Local0)
VISI += 1
} ElseIf (NUMB == 5) {
Local0 = LoadTable("DSDT", "", "", "", "PARA", Local0)
VISI += 10
} ElseIf (NUMB == 7) {
Local0 = LoadTable("DSDT", "", "TESTTABL", "", "", Local0)
VISI += 100
} Else {
Local0 = LoadTable("DSDT", "uTEST", "TESTTABL", "", "PARA", Local0)
VISI += 1000
}
// The last load is expected to fail, everything before should succeed
If (!Local0) {
If (NUMB != 10) {
NUMA = 0xDEADBEEF
Printf("Table load %o failed", NUMB)
}
} Else {
NUMA += 1
}
// Return something bogus here to make sure the return value isn't
// propagated to the caller of Load.
Return (Package { 1, 2 ,3})
}
// We're the last table load, do something naughty to cause an error
Local0 = Package { 1 }
Local1 = RefOf(Local0)
// This code specifically attempts to perform a bogus implicit cast
Local1 = "Hello World"
}
Name (ITEM, 123)
// Number of started table loads
Name (NUMB, 0)
// Number of finished table loads
Name (NUMA, 0)
// Visited branches
Name (VISI, 0)
Name (PARA, 0)
Name (PASS, "FAIL")
Method (MAIN, 0, Serialized)
{
Local0 = LoadTable("DSDT", "uTEST", "TESTTABL", "", "PASS", 0x53534150)
Printf("Recursive loads finished!")
If (!Local0) {
Printf("Table load failed!")
Return (0xCAFEBABE)
}
If (NUMB != 10) {
Printf("Invalid NUMB value %o", ToDecimalString(NUMB))
Return (0xEEFFAABB)
}
If (VISI != 7111) {
Printf("Invalid VISI value %o", ToDecimalString(VISI))
Return (0xAFFAAFFA)
}
If (NUMA != 9) {
Printf("Invalid NUMA value %o", ToDecimalString(NUMA))
Return (0x11223344)
}
If (PARA != 1) {
Printf("Invalid PARA value %o", ToDecimalString(PARA))
Return (0xDDFFBBCC)
}
If (PASS != "PASS") {
Printf("Invalid PASS value %o", PASS)
Return (0xECECECEC)
}
Return (0)
}
}

124
kernel/hal/x86_64/uACPI/tests/test-cases/table-loading-4.asl Normal file
View File

@ -0,0 +1,124 @@
// Name: LoadTable scoping rules are correct
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
External(SSDT, IntObj)
External(VAL, IntObj)
// All dynamic loads branch into here
If (CondRefOf(SSDT)) {
Name (TEST, 0)
TEST = VAL
Return (Package { 1 })
}
Name (SSDT, 123)
Name (VAL, 1)
Device (DEV0) {
Name (LRES, 0)
}
Device (DEV1) { }
Scope (_SB) {
Device (DEV1) {
Name (LRES, "XX")
Device (DEV1) { }
}
}
Name (LRES, 99)
Device (DEV2) {
Name (LRES, 123)
}
Method (LDTB, 3) {
Local0 = LoadTable("DSDT", "uTEST", "TESTTABL", Arg0, Arg1, Arg2)
VAL += 1
If (!Local0) {
Printf("Table load failed!")
Return (0)
}
Return (1)
}
Method (MAIN)
{
/*
* DEV0 is the scope, LRES should be evaluated relative to it.
* TEST is expected to be loaded there as well.
*/
If (!LDTB("DEV0", "LRES", 0xFEBEFEBE)) {
Return (1)
}
If (!CondRefOf(\DEV0.TEST, Local0)) {
Printf("No TEST under \\DEV0")
Return (1)
}
If (DerefOf(Local0) != 1) {
Printf("Incorrect \\DEV0.TEST value %o", DerefOf(Local0))
Return (1)
}
If (\DEV0.LRES != 0xFEBEFEBE) {
Printf("\\DEV0.LRES has an incorrect value %o", \DEV0.LRES)
Return (1)
}
CopyObject(0, Local0)
Scope (\_SB.DEV1) {
/*
* We're already inside \_SB.DEV1, so this DEV1 should match
* \_SB.DEV1.DEV1, note that there's also \DEV1, that shouldn't
* get matched here.
*
* There's, however, no \_SB.DEV1.DEV1.LRES, so this should resolve
* into \_SB.DEV1.LRES instead.
*/
Local0 = LoadTable("DSDT", "uTEST", "TESTTABL", "DEV1", "LRES", 0x4B4F)
If (!Local0) {
Printf("Table load failed!")
Return (0)
}
VAL += 1
}
If (!CondRefOf(\_SB.DEV1.DEV1.TEST, Local0)) {
Printf("No TEST under _SB.DEV1.DEV1")
Return (1)
}
If (DerefOf(Local0) != 2) {
Printf("Incorrect \\_SB.DEV1.DEV1.TEST value %o", DerefOf(Local0))
}
If (\_SB.DEV1.LRES != "OK") {
Printf("DEV1.LRES has an incorrect value %o", \_SB.DEV1.LRES)
Return (1)
}
CopyObject(0, Local0)
/*
* DEV2 relative load, however, LRES is specified as an absolute path
* so it shouldn't get resolved to DEV2.LRES.
*/
If (!LDTB("DEV2", "\\LRES", 0xCAFEBABE)) {
Return (1)
}
If (!CondRefOf(\DEV2.TEST, Local0)) {
Printf("No TEST under \\DEV2")
Return (1)
}
If (DerefOf(Local0) != 3) {
Printf("Incorrect \\DEV2.TEST value %o", DerefOf(Local0))
Return (1)
}
If (\LRES != 0xCAFEBABE) {
Printf("\\LRES has an incorrect value %o", \LRES)
Return (1)
}
Return (0)
}
}

64
kernel/hal/x86_64/uACPI/tests/test-cases/table-loading-5.asl Normal file
View File

@ -0,0 +1,64 @@
// Name: Load/LoadTable handle bogus-sized tables correctly
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
External(\SSDT, IntObj)
External(\OK, IntObj)
External(\TYPE, IntObj)
// All dynamic loads branch into here
If (CondRefOf(\OK)) {
if (TYPE == 0) {
Local0 = Load(\SSDT)
} Else {
DataTableRegion (DSDT, "DSDT", "uTEST", "TESTTABL")
Field (DSDT, DwordAcc, NoLock, Preserve) {
SIGN, 32,
LENG, 32,
}
// Make our own length bogus, then try to load ourselves, this should fail
LENG = 3
LoadTable("DSDT", "uTEST", "TESTTABL", "", "", 0)
}
// Should be unreachable, we expect the Load above to abort us
OK += 1
Return (0)
}
Name (SSDT, Buffer {
0x53, 0x53, 0x44, 0x54, 0x2a, 0x00, 0x00, 0x00,
0x01, 0x89, 0x75, 0x54, 0x45, 0x53, 0x54, 0x00,
0x42, 0x41, 0x44, 0x54, 0x42, 0x4c, 0x00, 0x00,
0xf0, 0xf0, 0xf0, 0xf0, 0x49, 0x4e, 0x54, 0x4c,
0x28, 0x06, 0x23, 0x20, 0x70, 0x0d, 0x3f, 0x00,
0x5b, 0x31
})
Name (OK, 0)
Name (TYPE, 0)
Method (MAIN) {
// Make the size something bogus
SSDT[4] = 0x11
SSDT[5] = 0
SSDT[6] = 0
SSDT[7] = 0
// Try Load'ing a bogus length SSDT
TYPE = 0
Local0 = LoadTable("DSDT", "uTEST", "TESTTABL", "", "", 0)
// Now try LoadTable ourselves, after corrupting our own length
TYPE = 1
Local0 = LoadTable("DSDT", "uTEST", "TESTTABL", "", "", 0)
// Expect the above to fail
if (Local0 || OK) {
Return (1)
}
Return (0)
}
}

70
kernel/hal/x86_64/uACPI/tests/test-cases/table-overrides.asl Normal file
View File

@ -0,0 +1,70 @@
// Name: Table overrides work
// Expect: int => 0
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
/*
* We expect this table to be denied by the test-runner because it denies
* anything with "DENYTABL" in OEM table id.
*
* DefinitionBlock ("x.aml", "SSDT", 1, "uTEST", "DENYTABL", 0xF0F0F0F0)
* {
* Name (BUG, 1)
* }
*/
Name (TAB0, Buffer {
0x53, 0x53, 0x44, 0x54, 0x2a, 0x00, 0x00, 0x00,
0x01, 0xe1, 0x75, 0x54, 0x45, 0x53, 0x54, 0x00,
0x44, 0x45, 0x4e, 0x59, 0x54, 0x41, 0x42, 0x4c,
0xf0, 0xf0, 0xf0, 0xf0, 0x49, 0x4e, 0x54, 0x4c,
0x28, 0x06, 0x23, 0x20, 0x08, 0x42, 0x55, 0x47,
0x5f, 0x01
})
/*
* We expect this table to be overriden by the test-runner because it
* overrides anything with "OVERTABL" in OEM table id. The override it
* provides has a Name(VAL, "TestRunner")
*
* DefinitionBlock ("x.aml", "SSDT", 1, "uTEST", "OVERTABL", 0xF0F0F0F0)
* {
* Name (VAL, "Hello")
* }
*/
Name (TAB1, Buffer {
0x53, 0x53, 0x44, 0x54, 0x30, 0x00, 0x00, 0x00,
0x01, 0xcd, 0x75, 0x54, 0x45, 0x53, 0x54, 0x00,
0x4f, 0x56, 0x45, 0x52, 0x54, 0x41, 0x42, 0x4c,
0xf0, 0xf0, 0xf0, 0xf0, 0x49, 0x4e, 0x54, 0x4c,
0x25, 0x09, 0x20, 0x20, 0x08, 0x56, 0x41, 0x4c,
0x5f, 0x0d, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x00
})
Method (MAIN, 0, NotSerialized)
{
Load(TAB0, Local0)
If (Local0) {
Debug = "Table was not denied load"
Return (0xDEAD)
}
If (CondRefOf(BUG)) {
Debug = "Table was not loaded but the BUG object exists"
Return (0xDEAD)
}
Load(TAB1, Local0)
If (!Local0) {
Debug = "Failed to load table"
Return (0xDEAD)
}
If (VAL != "TestRunner") {
Printf("Table didn't get overriden correctly: expected %o got %o",
"TestRunner", VAL)
Return (0xDEAD)
}
Return (0)
}
}

113
kernel/hal/x86_64/uACPI/tests/test-cases/to-integer.asl Normal file
View File

@ -0,0 +1,113 @@
// Name: ToInteger produces correct results
// Expect: int => 0
DefinitionBlock ("", "SSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name(FCNT, 0)
Method (CHEK, 3)
{
If (Arg0 != Arg1) {
FCNT++
Printf("On line %o: invalid number %o, expected %o",
ToDecimalString(Arg2), ToHexString(Arg0), ToHexString(Arg1))
}
}
Method (MAIN, 0, NotSerialized)
{
Local0 = ToInteger(123)
Local1 = 123
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("123")
Local1 = 123
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger(" \t\t\t\v 123")
Local1 = 123
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("123abcd")
Local1 = 123
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0x123abcd")
Local1 = 0x123abcd
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("")
Local1 = 0
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0X")
Local1 = 0
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0x")
Local1 = 0
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0")
Local1 = 0
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0xDeAdBeeF")
Local1 = 0xDEADBEEF
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0XDeAdBeeFCafeBabeHelloWorld")
Local1 = 0xDEADBEEFCAFEBABE
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger(Buffer { 0xDE, 0xAD, 0xBE, 0xEF })
Local1 = 0xEFBEADDE
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger(Buffer { 1 })
Local1 = 1
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger(Buffer { 0 })
Local1 = 0
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger(Buffer { 0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE })
Local1 = 0xBEBAFECAEFBEADDE
CHEK(Local0, Local1, __LINE__)
// These are incompatible with ACPICA, skip if it's detected
If (ToHexString(0xF) == "0xF") {
Local0 = ToInteger("99999999999999999999999999999999999999999999999")
Local1 = 0xFFFFFFFFFFFFFFFF
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0xDEADBEEFCAFEBABE1")
Local1 = 0xFFFFFFFFFFFFFFFF
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("+123")
Local1 = 123
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("-123")
Local1 = 0xFFFFFFFFFFFFFF85
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("-0xDEADBEF HELLOWORLD")
Local1 = 0xFFFFFFFFF2152411
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("+0XC0D\t123")
Local1 = 0xC0D
CHEK(Local0, Local1, __LINE__)
Local0 = ToInteger("0123")
Local1 = 83
CHEK(Local0, Local1, __LINE__)
}
Return (FCNT)
}
}

99
kernel/hal/x86_64/uACPI/tests/test-cases/to-x.asl Normal file
View File

@ -0,0 +1,99 @@
// Name: ToX produces correct results
// Expect: int => 0
DefinitionBlock ("", "SSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Name(FCNT, 0)
Method (CHEK, 2)
{
If (ObjectType(Arg0) == 3) {
Arg0 = ToHexString(Arg0)
}
If (ObjectType(Arg1) == 3) {
Arg1 = ToHexString(Arg1)
}
If (Arg0 != Arg1) {
FCNT++
Printf("Invalid string %o, expected %o", Arg0, Arg1)
}
}
Method (MAIN, 0, NotSerialized)
{
// Dec string
Local0 = ToDecimalString(123)
Local1 = "123"
CHEK(Local0, Local1)
Local0 = ToDecimalString(Buffer { 1, 2, 222, 33, 45, 192, 3, 255 })
Local1 = "1,2,222,33,45,192,3,255"
CHEK(Local0, Local1)
Local0 = ToDecimalString("")
Local1 = ""
CHEK(Local0, Local1)
Local0 = ToDecimalString("123")
Local1 = "123"
CHEK(Local0, Local1)
Local0 = ToDecimalString(0xFFFFFFFFFFFFFFFF)
Local1 = "18446744073709551615"
CHEK(Local0, Local1)
// Hex string
Local0 = ToHexString(123)
Local1 = "0x7B"
CHEK(Local0, Local1)
Local0 = ToHexString(Buffer { 1, 2, 222, 33, 45, 192, 3, 255 })
Local1 = "0x01,0x02,0xDE,0x21,0x2D,0xC0,0x03,0xFF"
CHEK(Local0, Local1)
Local0 = ToHexString("")
Local1 = ""
CHEK(Local0, Local1)
Local0 = ToHexString("123")
Local1 = "123"
CHEK(Local0, Local1)
Local0 = ToHexString(0xF)
Local1 = "0xF"
CHEK(Local0, Local1)
Local0 = ToHexString(0xFF)
Local1 = "0xFF"
CHEK(Local0, Local1)
Local0 = ToHexString(0xFFF)
Local1 = "0xFFF"
CHEK(Local0, Local1)
Local0 = ToHexString(0xFFFFF)
Local1 = "0xFFFFF"
CHEK(Local0, Local1)
Local0 = ToHexString(0xFFFFFFFFFFFFFFFF)
Local1 = "0xFFFFFFFFFFFFFFFF"
CHEK(Local0, Local1)
// Buffer
Local0 = ToBuffer(Buffer { 1, 2, 3 })
Local1 = Buffer { 1, 2, 3 }
CHEK(Local0, Local1)
Local0 = ToBuffer("Hello")
Local1 = Buffer { 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00 }
CHEK(Local0, Local1)
Local0 = ToBuffer(0xDEADBEEFCAFEBABE)
Local1 = Buffer { 0xBE, 0xBA, 0xFE, 0xCA, 0xEF, 0xBE, 0xAD, 0xDE }
CHEK(Local0, Local1)
Return (FCNT)
}
}

30
kernel/hal/x86_64/uACPI/tests/test-cases/unresolved-paths.asl Normal file
View File

@ -0,0 +1,30 @@
// Name: Unresolved paths don't error out when needed
// Expect: int => 1
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = Package {
321,
PATH.THAT.DOES.NOT_.EXIS.T,
123,
\OK,
\MAIN,
}
Debug = Local0
If (CondRefOf(ANOT.HER_.PATH.THAT.DOES.NOT.EXIS.T, Local0) ||
CondRefOf(\TEST) || CondRefOf(^TEST) || CondRefOf(^TEST.JEST) ||
CondRefOf(\TEST.JEST)) {
Return (0)
}
If (CondRefOf(^MAIN, Local1)) {
Debug = Local1
Return (1)
}
Return (0)
}
}

24
kernel/hal/x86_64/uACPI/tests/test-cases/while-break.asl Normal file
View File

@ -0,0 +1,24 @@
// Name: While With Break
// Expect: int => 10
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = 1
Local1 = 10
While (Local0) {
If (Local1--) {
Debug = "Incrementing Local0"
Local0++
Debug = Local0
} Else {
Debug = "Local1 is 0, breaking"
Break
}
}
Return(Local0)
}
}

25
kernel/hal/x86_64/uACPI/tests/test-cases/while-continue.asl Normal file
View File

@ -0,0 +1,25 @@
// Name: While With Continue
// Expect: int => 10
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = 1
Local1 = 10
While (Local0) {
If (Local1--) {
Debug = "Incrementing Local0 & continuing"
Local0++
Debug = Local0
Continue
}
Debug = "Local1 is 0, breaking"
Break
}
Return(Local0)
}
}

20
kernel/hal/x86_64/uACPI/tests/test-cases/while-dec-inc.asl Normal file
View File

@ -0,0 +1,20 @@
// Name: Increment/Decrement With While
// Expect: int => 10
DefinitionBlock ("", "DSDT", 2, "uTEST", "TESTTABL", 0xF0F0F0F0)
{
Method (MAIN, 0, NotSerialized)
{
Local0 = 1
Local1 = 10
While (Local1--) {
Debug = "Iteration"
Debug = Local0
Local0++
}
Return(Local0)
}
}