dsdt.asl

xen虚拟机源代码安装包

                        IO (Decode16, 0x00A2, 0x00A2, 0x00, 0x1C)
                        IO (Decode16, 0x00E0, 0x00E0, 0x00, 0x10)
                        IO (Decode16, 0x08A0, 0x08A0, 0x00, 0x04)
                        IO (Decode16, 0x0CC0, 0x0CC0, 0x00, 0x10)
                        IO (Decode16, 0x04D0, 0x04D0, 0x00, 0x02)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        Return (CRS)
                    }
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                        IRQNoFlags () {2}
                    })
                }

                Device (DMA0)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        DMA (Compatibility, BusMaster, Transfer8) {4}
                        IO (Decode16, 0x0000, 0x0000, 0x00, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x00, 0x03)
                        IO (Decode16, 0x0087, 0x0087, 0x00, 0x01)
                        IO (Decode16, 0x0089, 0x0089, 0x00, 0x03)
                        IO (Decode16, 0x008F, 0x008F, 0x00, 0x01)
                        IO (Decode16, 0x00C0, 0x00C0, 0x00, 0x20)
                        IO (Decode16, 0x0480, 0x0480, 0x00, 0x10)
                    })
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x00, 0x04)
                        IRQNoFlags () {0}
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x00, 0x02)
                        IRQNoFlags () {8}
                    })
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0061, 0x0061, 0x00, 0x01)
                    })
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CID, 0x130FD041)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags () {12}
                    })
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CID, 0x0B03D041)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x00, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x00, 0x01)
                        IRQNoFlags () {1}
                    })
                }

                Device (FDC0)
                {
                    Name (_HID, EisaId ("PNP0700"))
                    Method (_STA, 0, NotSerialized)
                    {
                          Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
                        IRQNoFlags () {6}
                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
                    })
                }

                Device (UAR1)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Name (_UID, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        If(LEqual(\_SB.UAR1, 0)) {
                            Return(0x00)
                        } Else {
                            Return(0x0F)
                        }
                    }

                    Name (_CRS, ResourceTemplate()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 8, 8)
                        IRQNoFlags () {4}
                    })
                }

                Device (UAR2)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        If(LEqual(\_SB.UAR2, 0)) {
                            Return(0x00)
                        } Else {
                            Return(0x0F)
                        }
                    }

                    Name (_CRS, ResourceTemplate()
                    {
                        IO (Decode16, 0x02F8, 0x02F8, 8, 8)
                        IRQNoFlags () {3}
                    })
                }

                Device (LTP1)
                {
                    Name (_HID, EisaId ("PNP0400"))
                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_CRS, ResourceTemplate()
                    {
                        IO (Decode16, 0x0378, 0x0378, 0x08, 0x08)
                        IRQNoFlags () {7}
                    })
                } 
            }

            /******************************************************************
             * Each PCI hotplug slot needs at least two methods to handle
             * the ACPI event:
             *  _EJ0: eject a device
             *  _STA: return a device's status, e.g. enabled or removed
             * Other methods are optional: 
             *  _PS0/3: put them here for debug purpose
             * 
             * Eject button would generate a general-purpose event, then the
             * control method for this event uses Notify() to inform OSPM which
             * action happened and on which device.
             *
             * Pls. refer "6.3 Device Insertion, Removal, and Status Objects"
             * in ACPI spec 3.0b for details.
             *
             * QEMU provides a simple hotplug controller with some I/O to
             * handle the hotplug action and status, which is beyond the ACPI
             * scope.
             */

            Device (S1F0)
            {
                Name (_ADR, 0x00060000) /* Dev 6, Func 0 */
                Name (_SUN, 0x00000001)

                Method (_PS0, 0)
                {
                    Store (0x80, \_GPE.DPT2)
                }

                Method (_PS3, 0)
                {
                    Store (0x83, \_GPE.DPT2)
                }

                Method (_EJ0, 1)
                {
                    Store (0x88, \_GPE.DPT2)
                    Store (0x1, \_GPE.PHP1) /* eject php slot 1*/
                }

                Method (_STA, 0)
                {
                    Store (0x89, \_GPE.DPT2)
                    Return ( \_GPE.PHP1 )   /* IN status as the _STA */
                }
            }

            Device (S2F0)
            {
                Name (_ADR, 0x00070000) /* Dev 7, Func 0 */
                Name (_SUN, 0x00000002)

                Method (_PS0, 0)
                {
                    Store (0x90, \_GPE.DPT2)
                }

                Method (_PS3, 0)
                {
                    Store (0x93, \_GPE.DPT2)
                }

                Method (_EJ0, 1)
                {
                    Store (0x98, \_GPE.DPT2)
                    Store (0x1, \_GPE.PHP2) /* eject php slot 1*/
                }

                Method (_STA, 0)
                {
                    Store (0x99, \_GPE.DPT2)
                    Return ( \_GPE.PHP2 )   /* IN status as the _STA */
                }
            }
        }
    }

    Scope (\_GPE)
    {
        OperationRegion (PHP, SystemIO, 0x10c0, 0x03)
        Field (PHP, ByteAcc, NoLock, Preserve)
        {
            PSTA,   8, /* hotplug controller status reg */
            PHP1,   8, /* hotplug slot 1 control reg */
            PHP2,   8  /* hotplug slot 2 control reg */
        }
        OperationRegion (DG1, SystemIO, 0xb044, 0x04)
        Field (DG1, ByteAcc, NoLock, Preserve)
        {
            DPT1,   8,
            DPT2,   8
        }
        Method (_L03, 0, NotSerialized)
        {
            /* detect slot and event(remove/add) */
            Name (SLT, 0x0)
            Name (EVT, 0x0)
            Store (PSTA, Local1)
            ShiftRight (Local1, 0x4, SLT)
            And (Local1, 0xf, EVT)

            /* debug */
            Store (SLT, DPT1)
            Store (EVT, DPT2)

            If ( LEqual(SLT, 0x1) )
            {
                Notify (\_SB.PCI0.S1F0, EVT)
            }
            ElseIf ( LEqual(SLT, 0x2) )
            {
                Notify (\_SB.PCI0.S2F0, EVT)
            }
        }
    }
}