// 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)
    }
}