acpi_video on SONY VAIO PCG-Z1 [was: acpi_video users needed]

Toxa postfix at sendmail.ru
Mon Aug 30 03:36:15 PDT 2004


On Mon, Aug 30, 2004 at 12:26:36PM +0400, Vladimir Grebenschikov wrote:
> Hi

> Is any chance to make acpi_video work on SONY VAIO PCG-Z1 ?
> acpi_video.ko loads well, but does not report anything, and does not add
> hw.acpi.video subtree.

this is known problem. I have it on vaio pcg-v505 as well, for years


> -- 
> Vladimir B. Grebenschikov
> SWsoft Inc. vova at sw-soft.com
> -- 
> Vladimir B. Grebenchikov
> vova at fbsd.ru

> /*
>   RSD PTR: OEM=PTLTD, ACPI_Rev=1.0x (0)
> 	RSDT=0x1ff7806b, cksum=56
>  */
> /*
>   RSDT: Length=48, Revision=1, Checksum=249,
> 	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
> 	Creator ID=PTL, Creator Revision=0x0
> 	Entries={ 0x1ff7bec2, 0x1ff7bfd8, 0x1ff7809b }
>  */
> /*
>   FACP: Length=132, Revision=2, Checksum=123,
> 	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
> 	Creator ID=PTL, Creator Revision=0x50
>  	FACS=0x1ff7cfc0, DSDT=0x1ff78507
> 	INT_MODEL=PIC
> 	Preferred_PM_Profile=Unspecified (0)
> 	SCI_INT=9
> 	SMI_CMD=0xb2, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
> 	PSTATE_CNT=0x80
> 	PM1a_EVT_BLK=0x1000-0x1003
> 	PM1a_CNT_BLK=0x1004-0x1005
> 	PM2_CNT_BLK=0x1020-0x1020
> 	PM_TMR_BLK=0x1008-0x100b
> 	GPE0_BLK=0x1028-0x102f
> 	P_LVL2_LAT=1 us, P_LVL3_LAT=1001 us
> 	FLUSH_SIZE=0, FLUSH_STRIDE=0
> 	DUTY_OFFSET=1, DUTY_WIDTH=3
> 	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
> 	IAPC_BOOT_ARCH={8042}
> 	Flags={WBINVD,PROC_C1,PWR_BUTTON,SLP_BUTTON,RTC_S4,RESET_REG}
> 	RESET_REG=0x64:0[8] (IO), RESET_VALUE=0xfe
>  */
> /*
>   FACS:	Length=64, HwSig=0x00000000, Firm_Wake_Vec=0x00000000
> 	Global_Lock=
> 	Flags=
> 	Version=0
>  */
> /*
>   DSDT: Length=14779, Revision=1, Checksum=101,
> 	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
> 	Creator ID=PTL, Creator Revision=0x100000d
>  */
> /*
>   BOOT: Length=40, Revision=1, Checksum=71,
> 	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
> 	Creator ID=PTL, Creator Revision=0x1
>  */
> /*
>   SSDT: Length=728, Revision=1, Checksum=237,
> 	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
> 	Creator ID=PTL, Creator Revision=0x0
>  */
> /*
>  * Intel ACPI Component Architecture
>  * AML Disassembler version 20040527
>  *
>  * Disassembly of /tmp/acpidump.QDyspP, Mon Aug 30 11:56:06 2004
>  */
> DefinitionBlock ("DSDT.aml", "DSDT", 1, "SONY", "G0", 537071905)
> {
>     OperationRegion (PORT, SystemIO, 0x80, 0x01)
>     Field (PORT, ByteAcc, NoLock, Preserve)
>     {
>         P80H,   8
>     }

>     OperationRegion (IO_T, SystemIO, 0x0800, 0x08)
>     Field (IO_T, ByteAcc, NoLock, Preserve)
>     {
>         TRP0,   8
>     }

>     OperationRegion (GPIO, SystemIO, 0x1180, 0x3C)
>     Field (GPIO, ByteAcc, NoLock, Preserve)
>     {
>         GU00,   8, 
>         GU01,   8, 
>         GU02,   8, 
>         GU03,   8, 
>         GIO0,   8, 
>         GIO1,   8, 
>         GIO2,   8, 
>         GIO3,   8, 
>         Offset (0x0C), 
>         GL00,   8, 
>         GL01,   8, 
>         GL02,   8, 
>         GL03,   8, 
>         Offset (0x18), 
>         GB00,   8, 
>         GB01,   8, 
>         GB02,   8, 
>         GB03,   8, 
>         Offset (0x2C), 
>         GIV0,   8, 
>         GIV1,   8, 
>         GIV2,   8, 
>         GIV3,   8, 
>         GU04,   8, 
>         GU05,   8, 
>         GU06,   8, 
>         GU07,   8, 
>         GIO4,   8, 
>         GIO5,   8, 
>         GIO6,   8, 
>         GIO7,   8, 
>             ,   1, 
>             ,   1, 
>         CPEN,   1, 
>         Offset (0x39), 
>         GL05,   8, 
>         GL06,   8, 
>         GL07,   8
>     }

>     OperationRegion (MNVS, SystemMemory, 0x1FF7CAB7, 0x40)
>     Field (MNVS, AnyAcc, Lock, Preserve)
>     {
>         PSAC,   8, 
>         PSDC,   8
>     }

>     Mutex (MUTX, 0x00)
>     Name (_S0, Package (0x03)
>     {
>         0x00, 
>         0x00, 
>         0x00
>     })
>     Name (_S3, Package (0x03)
>     {
>         0x05, 
>         0x05, 
>         0x00
>     })
>     Name (_S4, Package (0x03)
>     {
>         0x06, 
>         0x06, 
>         0x00
>     })
>     Name (_S5, Package (0x03)
>     {
>         0x07, 
>         0x07, 
>         0x00
>     })
>     Scope (\_PR)
>     {
>         Processor (CPU0, 0x00, 0x00001010, 0x06)
>         {
>             Scope (\)
>             {
>                 Name (GVSS, One)
>             }

>             Scope (\_PR.CPU0)
>             {
>                 Method (_CST, 0, NotSerialized)
>                 {
>                     If (\_SB.PCI0.LPCB.EC0.ECOK)
>                     {
>                         Store (\_SB.PCI0.LPCB.EC0.ACAT, Local0)
>                     }
>                     Else
>                     {
>                         And (PHSD (0xD4, 0x80), 0x0400, Local0)
>                     }

>                     If (Local0)
>                     {
>                         Return (ACST)
>                     }
>                     Else
>                     {
>                         If (GVSS)
>                         {
>                             Return (DCST)
>                         }
>                         Else
>                         {
>                             Return (DDST)
>                         }
>                     }
>                 }

>                 Name (ACST, Package (0x03)
>                 {
>                     0x02, 
>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
>                         }, 

>                         0x01, 
>                         0x01, 
>                         0x03E8
>                     }, 

>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
>                         }, 

>                         0x02, 
>                         0x01, 
>                         0x01F4
>                     }
>                 })
>                 Name (DCST, Package (0x05)
>                 {
>                     0x04, 
>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
>                         }, 

>                         0x01, 
>                         0x01, 
>                         0x03E8
>                     }, 

>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
>                         }, 

>                         0x02, 
>                         0x01, 
>                         0x01F4
>                     }, 

>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (SystemIO, 0x08, 0x00, 0x0000000000001015)
>                         }, 

>                         0x03, 
>                         0x55, 
>                         0xFA
>                     }, 

>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (SystemIO, 0x08, 0x00, 0x0000000000001016)
>                         }, 

>                         0x03, 
>                         0xB9, 
>                         0x64
>                     }
>                 })
>                 Name (DDST, Package (0x04)
>                 {
>                     0x03, 
>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
>                         }, 

>                         0x01, 
>                         0x01, 
>                         0x03E8
>                     }, 

>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
>                         }, 

>                         0x02, 
>                         0x01, 
>                         0x01F4
>                     }, 

>                     Package (0x04)
>                     {
>                         ResourceTemplate ()
>                         {
>                             Register (SystemIO, 0x08, 0x00, 0x0000000000001015)
>                         }, 

>                         0x03, 
>                         0x55, 
>                         0xFA
>                     }
>                 })
>             }
>         }
>     }

>     Name (\CTYP, 0x00)
>     Name (\ECON, 0x00)
>     Method (_PTS, 1, NotSerialized)
>     {
>         Store (Arg0, P80H)
>         If (LEqual (Arg0, 0x03))
>         {
>             Store (\_SB.PCI0.LPCB.SPIC._CRS (), \_SB.PCI0.LPCB.SPIC.SSRC)
>         }

>         If (LEqual (Arg0, 0x04))
>         {
>             Store (\_SB.PCI0.LPCB.SPIC._CRS (), \_SB.PCI0.LPCB.SPIC.SSRC)
>             PHSB (0xA2, \_SB.OSTB)
>         }
>     }

>     Method (_WAK, 1, NotSerialized)
>     {
>         Store (0x00, P80H)
>         \_SB.NCPU ()
>         If (LEqual (Arg0, 0x03))
>         {
>             \_SB.PCI0.LPCB.SPIC._SRS (\_SB.PCI0.LPCB.SPIC.SSRC)
>             If (LNot (\_SB.PCI0.LPCB.EC0.WAKI))
>             {
>                 Notify (\_SB.PWRB, 0x02)
>             }
>         }

>         If (LEqual (Arg0, 0x04))
>         {
>             \_SB.PCI0.LPCB.SPIC._SRS (\_SB.PCI0.LPCB.SPIC.SSRC)
>             PHSB (0xA3, \_SB.OSTB)
>             Notify (\_SB.PWRB, 0x02)
>         }

>         Return (Zero)
>     }

>     Scope (\_SB)
>     {
>         Name (OSTB, Ones)
>         OperationRegion (OSTY, SystemMemory, 0x1FF7CAF7, 0x00000001)
>         Field (OSTY, AnyAcc, NoLock, Preserve)
>         {
>             TPOS,   8
>         }

>         Method (OSTP, 0, NotSerialized)
>         {
>             If (LEqual (^OSTB, Ones))
>             {
>                 If (CondRefOf (\_OSI, Local0))
>                 {
>                     If (\_OSI ("Windows 2001.1"))
>                     {
>                         Store (0x20, ^OSTB)
>                         Store (0x20, ^TPOS)
>                     }
>                     Else
>                     {
>                         If (\_OSI ("Windows 2001 SP1"))
>                         {
>                             Store (0x10, ^OSTB)
>                             Store (0x10, ^TPOS)
>                         }
>                         Else
>                         {
>                             If (\_OSI ("Windows 2001"))
>                             {
>                                 Store (0x08, ^OSTB)
>                                 Store (0x08, ^TPOS)
>                             }
>                             Else
>                             {
>                                 Store (0x00, ^OSTB)
>                                 Store (0x00, ^TPOS)
>                             }
>                         }
>                     }
>                 }
>                 Else
>                 {
>                     If (CondRefOf (\_OS, Local0))
>                     {
>                         If (^SEQL (\_OS, "Microsoft Windows"))
>                         {
>                             Store (0x01, ^OSTB)
>                             Store (0x01, ^TPOS)
>                         }
>                         Else
>                         {
>                             If (^SEQL (\_OS, "Microsoft WindowsME: Millennium Edition"))
>                             {
>                                 Store (0x02, ^OSTB)
>                                 Store (0x02, ^TPOS)
>                             }
>                             Else
>                             {
>                                 If (^SEQL (\_OS, "Microsoft Windows NT"))
>                                 {
>                                     Store (0x04, ^OSTB)
>                                     Store (0x04, ^TPOS)
>                                 }
>                                 Else
>                                 {
>                                     Store (0x00, ^OSTB)
>                                     Store (0x00, ^TPOS)
>                                 }
>                             }
>                         }
>                     }
>                     Else
>                     {
>                         Store (0x00, ^OSTB)
>                         Store (0x00, ^TPOS)
>                     }
>                 }
>             }

>             Return (^OSTB)
>         }

>         Method (SEQL, 2, Serialized)
>         {
>             Store (SizeOf (Arg0), Local0)
>             Store (SizeOf (Arg1), Local1)
>             If (LNot (LEqual (Local0, Local1)))
>             {
>                 Return (Zero)
>             }

>             Name (BUF0, Buffer (Local0) {})
>             Store (Arg0, BUF0)
>             Name (BUF1, Buffer (Local0) {})
>             Store (Arg1, BUF1)
>             Store (Zero, Local2)
>             While (LLess (Local2, Local0))
>             {
>                 Store (DerefOf (Index (BUF0, Local2)), Local3)
>                 Store (DerefOf (Index (BUF1, Local2)), Local4)
>                 If (LNot (LEqual (Local3, Local4)))
>                 {
>                     Return (Zero)
>                 }

>                 Increment (Local2)
>             }

>             Return (One)
>         }
>     }

>     Scope (\_GPE)
>     {
>         Mutex (GLOK, 0x00)
>         Method (_L03, 0, NotSerialized)
>         {
>             Notify (\_SB.PCI0.USB0, 0x02)
>         }

>         Method (_L04, 0, NotSerialized)
>         {
>             Notify (\_SB.PCI0.USB1, 0x02)
>         }

>         Method (_L05, 0, NotSerialized)
>         {
>             Notify (\_SB.PCI0.MODM, 0x02)
>         }

>         Method (_L0C, 0, NotSerialized)
>         {
>             Notify (\_SB.PCI0.USB2, 0x02)
>         }

>         Method (_L0D, 0, NotSerialized)
>         {
>             Notify (\_SB.PCI0.USB7, 0x02)
>         }

>         Method (_L0B, 0, NotSerialized)
>         {
>             If (LNot (LLess (\_SB.OSTB, 0x08)))
>             {
>                 Acquire (GLOK, 0xFFFF)
>                 Sleep (0x64)
>                 Notify (\_SB.PCI0.PCIB.CRD0, 0x02)
>                 Sleep (0x64)
>                 Release (GLOK)
>                 Notify (\_SB.PCI0.PCIB, 0x02)
>             }
>             Else
>             {
>                 Notify (\_SB.PCI0.PCIB, 0x02)
>             }
>         }

>         Method (_L1D, 0, NotSerialized)
>         {
>             Notify (\_SB.PCI0.LPCB.EC0, 0x02)
>         }
>     }

>     OperationRegion (SMI0, SystemMemory, 0x1FF7CAF8, 0x00000415)
>     Field (SMI0, AnyAcc, NoLock, Preserve)
>     {
>         BCMD,   8, 
>         DID,    32, 
>         INFO,   4096
>     }

>     Field (SMI0, AnyAcc, NoLock, Preserve)
>     {
>         Offset (0x05), 
>         INFB,   8
>     }

>     Field (SMI0, AnyAcc, NoLock, Preserve)
>     {
>         Offset (0x05), 
>         INFD,   32
>     }

>     Field (SMI0, AnyAcc, NoLock, Preserve)
>     {
>         Offset (0x05), 
>         SXBF,   8320
>     }

>     Field (SMI0, AnyAcc, NoLock, Preserve)
>     {
>         Offset (0x05), 
>         INF1,   8, 
>         INF2,   8
>     }

>     OperationRegion (SMI1, SystemIO, 0x0000FE00, 0x00000002)
>     Field (SMI1, AnyAcc, NoLock, Preserve)
>     {
>         SMIC,   8
>     }

>     Mutex (MPHS, 0x00)
>     Method (PHS0, 1, NotSerialized)
>     {
>         Store (Arg0, BCMD)
>         Store (Zero, SMIC)
>         While (LEqual (BCMD, Arg0)) {}
>         Store (0x00, BCMD)
>     }

>     Method (PHS, 1, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (0x00, DID)
>         PHS0 (Arg0)
>         Store (INFD, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Method (PHSD, 2, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (0x00, DID)
>         Store (Arg1, INFD)
>         PHS0 (Arg0)
>         Store (INFD, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Method (PHSW, 3, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (0x00, DID)
>         Store (Arg1, INF1)
>         Store (Arg2, INF2)
>         PHS0 (Arg0)
>         Store (INFB, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Method (PHSB, 2, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (0x00, DID)
>         Store (Arg1, INFB)
>         PHS0 (Arg0)
>         Store (INFB, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Method (PSCS, 1, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (Arg0, DID)
>         PHS0 (0x00)
>         Store (INFO, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Method (PSSS, 2, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (Arg0, DID)
>         Store (Arg1, INFO)
>         PHS0 (0x01)
>         Release (MPHS)
>     }

>     Method (PSPS, 1, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (Arg0, DID)
>         PHS0 (0x02)
>         Store (INFO, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Method (PSDI, 1, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (Arg0, DID)
>         PHS0 (0x03)
>         Release (MPHS)
>     }

>     Method (PSST, 1, Serialized)
>     {
>         Acquire (MPHS, 0xFFFF)
>         Store (Arg0, DID)
>         PHS0 (0x04)
>         Store (INFB, Local0)
>         Release (MPHS)
>         Return (Local0)
>     }

>     Scope (\_TZ)
>     {
>         ThermalZone (ATF0)
>         {
>             Method (KELV, 1, NotSerialized)
>             {
>                 Store (Arg0, Local0)
>                 Multiply (Local0, 0x0A, Local0)
>                 Add (Local0, 0x0AAB, Local0)
>                 Return (Local0)
>             }

>             Method (_TMP, 0, NotSerialized)
>             {
>                 If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                 {
>                     Store (PHSD (0xD4, 0xC0), Local1)
>                 }
>                 Else
>                 {
>                     Store (\_SB.PCI0.LPCB.EC0.A1TP, Local1)
>                 }

>                 ShiftRight (Local1, 0x08, Local0)
>                 If (LGreater (Local0, 0x80))
>                 {
>                     Sleep (0x32)
>                     If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                     {
>                         Store (PHSD (0xD4, 0xC0), Local1)
>                     }
>                     Else
>                     {
>                         Store (\_SB.PCI0.LPCB.EC0.A1TP, Local1)
>                     }

>                     ShiftRight (Local1, 0x08, Local0)
>                 }

>                 Return (KELV (Local0))
>             }

>             Method (_PSV, 0, NotSerialized)
>             {
>                 If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                 {
>                     Store (PHSD (0xD4, 0xC4), Local1)
>                 }
>                 Else
>                 {
>                     Store (\_SB.PCI0.LPCB.EC0.A1PT, Local1)
>                 }

>                 ShiftRight (Local1, 0x08, Local0)
>                 Return (KELV (Local0))
>             }

>             Name (_PSL, Package (0x01)
>             {
>                 \_PR.CPU0
>             })
>             Method (_CRT, 0, NotSerialized)
>             {
>                 If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                 {
>                     Store (PHSD (0xD4, 0xC6), Local1)
>                 }
>                 Else
>                 {
>                     Store (\_SB.PCI0.LPCB.EC0.A1CT, Local1)
>                 }

>                 ShiftRight (Local1, 0x08, Local0)
>                 Return (KELV (Local0))
>             }

>             Name (_TC1, 0x01)
>             Name (_TC2, 0x02)
>             Name (_TSP, 0x32)
>         }
>     }

>     Scope (\_SB)
>     {
>         Device (LID0)
>         {
>             Name (_HID, EisaId ("PNP0C0D"))
>             Method (_LID, 0, NotSerialized)
>             {
>                 If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                 {
>                     And (PHSB (0xD4, 0x82), 0x04, Local0)
>                 }
>                 Else
>                 {
>                     Store (\_SB.PCI0.LPCB.EC0.LIDS, Local0)
>                 }

>                 Return (Local0)
>             }
>         }

>         Device (PWRB)
>         {
>             Name (_HID, EisaId ("PNP0C0C"))
>             Name (_PRW, Package (0x02)
>             {
>                 0x1D, 
>                 0x04
>             })
>         }

>         Mutex (PLOK, 0x00)
>         Method (NCPU, 0, NotSerialized)
>         {
>             Acquire (PLOK, 0xFFFF)
>             Notify (\_PR.CPU0, 0x80)
>             Sleep (0x64)
>             Notify (\_PR.CPU0, 0x81)
>             Release (PLOK)
>         }

>         Device (PCI0)
>         {
>             Method (_INI, 0, NotSerialized)
>             {
>                 \_SB.OSTP ()
>             }

>             Method (_S1D, 0, NotSerialized)
>             {
>                 Return (0x02)
>             }

>             Method (_S3D, 0, NotSerialized)
>             {
>                 Return (0x02)
>             }

>             Method (_S4D, 0, NotSerialized)
>             {
>                 Return (0x02)
>             }

>             Name (_HID, EisaId ("PNP0A03"))
>             Name (_ADR, 0x00)
>             Name (_BBN, 0x00)
>             OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
>             Field (HBUS, DWordAcc, NoLock, Preserve)
>             {
>                 Offset (0x20), 
>                 DRB0,   8, 
>                 DRB1,   8, 
>                 DRB2,   8, 
>                 DRB3,   8, 
>                 Offset (0x50), 
>                     ,   4, 
>                 PM0H,   2, 
>                 Offset (0x51), 
>                 PM1L,   2, 
>                     ,   2, 
>                 PM1H,   2, 
>                 Offset (0x52), 
>                 PM2L,   2, 
>                     ,   2, 
>                 PM2H,   2, 
>                 Offset (0x53), 
>                 PM3L,   2, 
>                     ,   2, 
>                 PM3H,   2, 
>                 Offset (0x54), 
>                 PM4L,   2, 
>                     ,   2, 
>                 PM4H,   2, 
>                 Offset (0x55), 
>                 PM5L,   2, 
>                     ,   2, 
>                 PM5H,   2, 
>                 Offset (0x56), 
>                 PM6L,   2, 
>                     ,   2, 
>                 PM6H,   2, 
>                 Offset (0x57), 
>                 FDHC,   8
>             }

>             Name (BUF0, ResourceTemplate ()
>             {
>                 WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
>                     0x0000,
>                     0x0000,
>                     0x00FF,
>                     0x0000,
>                     0x0100, 0x00)
>                 DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                     0x00000000,
>                     0x00000000,
>                     0x00000CF7,
>                     0x00000000,
>                     0x00000CF8, 0x00)
>                 IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
>                 DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                     0x00000000,
>                     0x00000D00,
>                     0x0000FFFF,
>                     0x00000000,
>                     0x0000F300, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000A0000,
>                     0x000BFFFF,
>                     0x00000000,
>                     0x00020000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000C0000,
>                     0x000C3FFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000C4000,
>                     0x000C7FFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000C8000,
>                     0x000CBFFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000CC000,
>                     0x000CFFFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000D0000,
>                     0x000D3FFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000D4000,
>                     0x000D7FFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000D8000,
>                     0x000DBFFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000DC000,
>                     0x000DFFFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000E0000,
>                     0x000E3FFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000E4000,
>                     0x000E7FFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000E8000,
>                     0x000EBFFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000EC000,
>                     0x000EFFFF,
>                     0x00000000,
>                     0x00004000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x000F0000,
>                     0x000FFFFF,
>                     0x00000000,
>                     0x00010000, 0x00)
>                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                     0x00000000,
>                     0x00000000,
>                     0xFEBFFFFF,
>                     0x00000000,
>                     0x00000000, 0x00)
>             })
>             Method (_CRS, 0, Serialized)
>             {
>                 If (PM1L)
>                 {
>                     CreateDWordField (BUF0, 0x80, C0LN)
>                     Store (Zero, C0LN)
>                 }

>                 If (LEqual (PM1L, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0378, C0RW)
>                     Store (Zero, C0RW)
>                 }

>                 If (PM1H)
>                 {
>                     CreateDWordField (BUF0, 0x9B, C4LN)
>                     Store (Zero, C4LN)
>                 }

>                 If (LEqual (PM1H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0450, C4RW)
>                     Store (Zero, C4RW)
>                 }

>                 If (PM2L)
>                 {
>                     CreateDWordField (BUF0, 0xB6, C8LN)
>                     Store (Zero, C8LN)
>                 }

>                 If (LEqual (PM2L, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0528, C8RW)
>                     Store (Zero, C8RW)
>                 }

>                 If (PM2H)
>                 {
>                     CreateDWordField (BUF0, 0xD1, CCLN)
>                     Store (Zero, CCLN)
>                 }

>                 If (LEqual (PM2H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0600, CCRW)
>                     Store (Zero, CCRW)
>                 }

>                 If (PM3L)
>                 {
>                     CreateDWordField (BUF0, 0xEC, D0LN)
>                     Store (Zero, D0LN)
>                 }

>                 If (LEqual (PM3L, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x06D8, D0RW)
>                     Store (Zero, D0RW)
>                 }

>                 If (PM3H)
>                 {
>                     CreateDWordField (BUF0, 0x0107, D4LN)
>                     Store (Zero, D4LN)
>                 }

>                 If (LEqual (PM3H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x07B0, D4RW)
>                     Store (Zero, D4RW)
>                 }

>                 If (PM4L)
>                 {
>                     CreateDWordField (BUF0, 0x0122, D8LN)
>                     Store (Zero, D8LN)
>                 }

>                 If (LEqual (PM4L, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0888, D8RW)
>                     Store (Zero, D8RW)
>                 }

>                 If (PM4H)
>                 {
>                     CreateDWordField (BUF0, 0x013D, DCLN)
>                     Store (Zero, DCLN)
>                 }

>                 If (LEqual (PM4H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0960, DCRW)
>                     Store (Zero, DCRW)
>                 }

>                 If (PM5L)
>                 {
>                     CreateDWordField (BUF0, 0x0158, E0LN)
>                     Store (Zero, E0LN)
>                 }

>                 If (LEqual (PM5L, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0A38, E0RW)
>                     Store (Zero, E0RW)
>                 }

>                 If (PM5H)
>                 {
>                     CreateDWordField (BUF0, 0x0173, E4LN)
>                     Store (Zero, E4LN)
>                 }

>                 If (LEqual (PM5H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0B10, E4RW)
>                     Store (Zero, E4RW)
>                 }

>                 If (PM6L)
>                 {
>                     CreateDWordField (BUF0, 0x018E, E8LN)
>                     Store (Zero, E8LN)
>                 }

>                 If (LEqual (PM6L, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0BE8, E8RW)
>                     Store (Zero, E8RW)
>                 }

>                 If (PM6H)
>                 {
>                     CreateDWordField (BUF0, 0x01A9, ECLN)
>                     Store (Zero, ECLN)
>                 }

>                 If (LEqual (PM6H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0CC0, ECRW)
>                     Store (Zero, ECRW)
>                 }

>                 If (PM0H)
>                 {
>                     CreateDWordField (BUF0, 0x01C4, F0LN)
>                     Store (Zero, F0LN)
>                 }

>                 If (LEqual (PM0H, 0x01))
>                 {
>                     CreateBitField (BUF0, 0x0D98, F0RW)
>                     Store (Zero, F0RW)
>                 }

>                 CreateDWordField (BUF0, 0x01D3, M1MN)
>                 CreateDWordField (BUF0, 0x01D7, M1MX)
>                 CreateDWordField (BUF0, 0x01DF, M1LN)
>                 Multiply (0x02000000, DRB3, M1MN)
>                 Add (Subtract (M1MX, M1MN), 0x01, M1LN)
>                 Return (BUF0)
>             }

>             Method (_PRT, 0, NotSerialized)
>             {
>                 Return (Package (0x09)
>                 {
>                     Package (0x04)
>                     {
>                         0x0001FFFF, 
>                         0x00, 
>                         \_SB.PCI0.LPCB.LNKA, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x0001FFFF, 
>                         0x01, 
>                         \_SB.PCI0.LPCB.LNKB, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x0001FFFF, 
>                         0x02, 
>                         \_SB.PCI0.LPCB.LNKC, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x0001FFFF, 
>                         0x03, 
>                         \_SB.PCI0.LPCB.LNKD, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x001DFFFF, 
>                         0x00, 
>                         \_SB.PCI0.LPCB.LNKA, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x001DFFFF, 
>                         0x01, 
>                         \_SB.PCI0.LPCB.LNKD, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x001DFFFF, 
>                         0x02, 
>                         \_SB.PCI0.LPCB.LNKC, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x001DFFFF, 
>                         0x03, 
>                         \_SB.PCI0.LPCB.LNKH, 
>                         0x00
>                     }, 

>                     Package (0x04)
>                     {
>                         0x001FFFFF, 
>                         0x01, 
>                         \_SB.PCI0.LPCB.LNKB, 
>                         0x00
>                     }
>                 })
>             }

>             Device (AGPB)
>             {
>                 Name (_ADR, 0x00010000)
>                 Method (_PRT, 0, NotSerialized)
>                 {
>                     Return (Package (0x01)
>                     {
>                         Package (0x04)
>                         {
>                             0xFFFF, 
>                             0x00, 
>                             \_SB.PCI0.LPCB.LNKA, 
>                             0x00
>                         }
>                     })
>                 }

>                 Device (VID0)
>                 {
>                     Name (_ADR, 0x00)
>                     OperationRegion (VIDR, PCI_Config, 0x4C, 0x04)
>                     Field (VIDR, ByteAcc, NoLock, Preserve)
>                     {
>                         SSID,   32
>                     }

>                     Device (CRT)
>                     {
>                         Name (_ADR, 0x0100)
>                     }

>                     Device (LCD)
>                     {
>                         Name (_ADR, 0x0110)
>                     }

>                     Device (TV)
>                     {
>                         Name (_ADR, 0x0200)
>                     }
>                 }
>             }

>             Device (PCIB)
>             {
>                 Name (_ADR, 0x001E0000)
>                 Device (LANC)
>                 {
>                     Name (_ADR, 0x00080000)
>                     Name (_PRW, Package (0x02)
>                     {
>                         0x0B, 
>                         0x03
>                     })
>                 }

>                 Device (WLAN)
>                 {
>                     Name (_ADR, 0x000B0000)
>                     Name (_PSC, 0x00)
>                     Method (_PS0, 0, NotSerialized)
>                     {
>                         Store (0x00, _PSC)
>                     }

>                     Method (_PS3, 0, NotSerialized)
>                     {
>                         Store (0x03, _PSC)
>                     }

>                     Method (_STA, 0, NotSerialized)
>                     {
>                         Return (0x0F)
>                     }
>                 }

>                 Device (CRD0)
>                 {
>                     Name (_ADR, 0x00050000)
>                     OperationRegion (CCRD, PCI_Config, 0x00, 0xE4)
>                     Field (CCRD, DWordAcc, NoLock, Preserve)
>                     {
>                         Offset (0x04), 
>                         CD04,   32, 
>                         Offset (0x3E), 
>                         CD3E,   32, 
>                         Offset (0x44), 
>                         CD44,   32, 
>                         Offset (0xE0), 
>                         CDE0,   8, 
>                         CDE1,   8
>                     }

>                     Method (_INI, 0, NotSerialized)
>                     {
>                         Store (Zero, CD44)
>                     }

>                     Name (_PSC, 0x00)
>                     Method (_PS0, 0, NotSerialized)
>                     {
>                         Store (0x00, _PSC)
>                     }

>                     Method (_PS3, 0, NotSerialized)
>                     {
>                         Store (0x03, _PSC)
>                     }

>                     Method (_STA, 0, NotSerialized)
>                     {
>                         Return (0x0F)
>                     }

>                     Name (_PRW, Package (0x02)
>                     {
>                         0x0B, 
>                         0x03
>                     })
>                 }

>                 Device (SD94)
>                 {
>                     Name (_ADR, 0x00050001)
>                 }

>                 Method (_PRT, 0, NotSerialized)
>                 {
>                     Return (Package (0x05)
>                     {
>                         Package (0x04)
>                         {
>                             0x0005FFFF, 
>                             0x00, 
>                             \_SB.PCI0.LPCB.LNKF, 
>                             0x00
>                         }, 

>                         Package (0x04)
>                         {
>                             0x0005FFFF, 
>                             0x01, 
>                             \_SB.PCI0.LPCB.LNKG, 
>                             0x00
>                         }, 

>                         Package (0x04)
>                         {
>                             0x000BFFFF, 
>                             0x00, 
>                             \_SB.PCI0.LPCB.LNKD, 
>                             0x00
>                         }, 

>                         Package (0x04)
>                         {
>                             0x0004FFFF, 
>                             0x00, 
>                             \_SB.PCI0.LPCB.LNKE, 
>                             0x00
>                         }, 

>                         Package (0x04)
>                         {
>                             0x0008FFFF, 
>                             0x00, 
>                             \_SB.PCI0.LPCB.LNKE, 
>                             0x00
>                         }
>                     })
>                 }
>             }

>             Device (LPCB)
>             {
>                 Name (_ADR, 0x001F0000)
>                 OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
>                 Field (LPC0, AnyAcc, NoLock, Preserve)
>                 {
>                     Offset (0x20), 
>                     PIRA,   8, 
>                     PIRB,   8, 
>                     PIRC,   8, 
>                     PIRD,   8, 
>                     Offset (0x28), 
>                     PIRE,   8, 
>                     PIRF,   8, 
>                     PIRG,   8, 
>                     PIRH,   8, 
>                     Offset (0x90), 
>                     HPTE,   32, 
>                     Offset (0xA0), 
>                     LDE0,   8, 
>                     LDE1,   8
>                 }

>                 Device (LNKA)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x01)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRA)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLA, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLA, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRA, 0x0F), IRQ0)
>                         Return (RTLA)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRA)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRA, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKB)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x02)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRB)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLB, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLB, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRB, 0x0F), IRQ0)
>                         Return (RTLB)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRB)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRB, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKC)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x03)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRC)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLC, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLC, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRC, 0x0F), IRQ0)
>                         Return (RTLC)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRC)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRC, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKD)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x04)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRD)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLD, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLD, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRD, 0x0F), IRQ0)
>                         Return (RTLD)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRD)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRD, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKE)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x05)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRE)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLE, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLE, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRE, 0x0F), IRQ0)
>                         Return (RTLE)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRE)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRE, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKF)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x06)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRF)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLF, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLF, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRF, 0x0F), IRQ0)
>                         Return (RTLF)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRF)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRF, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKG)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x07)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRG)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLG, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLG, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRG, 0x0F), IRQ0)
>                         Return (RTLG)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRG)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRG, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (LNKH)
>                 {
>                     Name (_HID, EisaId ("PNP0C0F"))
>                     Name (_UID, 0x08)
>                     Method (_DIS, 0, Serialized)
>                     {
>                         Store (0x80, PIRH)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         IRQ (Level, ActiveLow, Shared) {9}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         Name (RTLH, ResourceTemplate ()
>                         {
>                             IRQ (Level, ActiveLow, Shared) {}
>                         })
>                         CreateWordField (RTLH, 0x01, IRQ0)
>                         Store (Zero, IRQ0)
>                         ShiftLeft (0x01, And (PIRH, 0x0F), IRQ0)
>                         Return (RTLH)
>                     }

>                     Method (_SRS, 1, Serialized)
>                     {
>                         CreateWordField (Arg0, 0x01, IRQ0)
>                         FindSetRightBit (IRQ0, Local0)
>                         Decrement (Local0)
>                         Store (Local0, PIRH)
>                     }

>                     Method (_STA, 0, Serialized)
>                     {
>                         If (And (PIRH, 0x80))
>                         {
>                             Return (0x09)
>                         }
>                         Else
>                         {
>                             Return (0x0B)
>                         }
>                     }
>                 }

>                 Device (TIMR)
>                 {
>                     Name (_HID, EisaId ("PNP0100"))
>                     Name (BUF0, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
>                         IO (Decode16, 0x0050, 0x0050, 0x10, 0x04)
>                     })
>                     Name (BUF1, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
>                         IO (Decode16, 0x0050, 0x0050, 0x10, 0x04)
>                         IRQNoFlags () {0}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         If (And (HPTE, 0x00020000))
>                         {
>                             Return (BUF0)
>                         }

>                         Return (BUF1)
>                     }
>                 }

>                 Device (IPIC)
>                 {
>                     Name (_HID, EisaId ("PNP0000"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
>                         IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
>                         IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
>                         IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
>                         IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
>                         IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
>                         IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
>                         IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
>                         IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
>                         IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
>                         IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
>                         IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
>                         IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x02)
>                         IO (Decode16, 0x00B4, 0x00B4, 0x01, 0x02)
>                         IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
>                         IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
>                         IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
>                         IRQNoFlags () {2}
>                     })
>                 }

>                 Device (RTC)
>                 {
>                     Name (_HID, EisaId ("PNP0B00"))
>                     Name (BUF0, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0070, 0x0070, 0x01, 0x08)
>                     })
>                     Name (BUF1, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0070, 0x0070, 0x01, 0x08)
>                         IRQNoFlags () {8}
>                     })
>                     Method (_CRS, 0, Serialized)
>                     {
>                         If (And (HPTE, 0x00020000))
>                         {
>                             Return (BUF0)
>                         }

>                         Return (BUF1)
>                     }
>                 }

>                 Device (MATH)
>                 {
>                     Name (_HID, EisaId ("PNP0C04"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x01)
>                         IRQNoFlags () {13}
>                     })
>                 }

>                 Device (DMAC)
>                 {
>                     Name (_HID, EisaId ("PNP0200"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
>                         IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
>                         IO (Decode16, 0x0090, 0x0090, 0x01, 0x02)
>                         IO (Decode16, 0x0093, 0x0093, 0x01, 0x0D)
>                         IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
>                         DMA (Compatibility, NotBusMaster, Transfer8_16) {4}
>                     })
>                 }

>                 Device (MBRD)
>                 {
>                     Name (_HID, EisaId ("PNP0C02"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
>                         IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
>                         IO (Decode16, 0x0063, 0x0063, 0x01, 0x01)
>                         IO (Decode16, 0x0065, 0x0065, 0x01, 0x01)
>                         IO (Decode16, 0x0067, 0x0067, 0x01, 0x01)
>                         IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
>                         IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
>                         IO (Decode16, 0x00B2, 0x00B2, 0x01, 0x02)
>                         IO (Decode16, 0x0600, 0x0600, 0x01, 0x10)
>                         IO (Decode16, 0x0700, 0x0700, 0x01, 0x10)
>                         IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
>                         IO (Decode16, 0x1180, 0x1180, 0x01, 0x40)
>                         IO (Decode16, 0xFE00, 0xFE00, 0x01, 0x02)
>                         IO (Decode16, 0xFE10, 0xFE10, 0x01, 0x08)
>                         Memory32Fixed (ReadWrite, 0xFEBFE000, 0x00001000)
>                         Memory32Fixed (ReadWrite, 0xFEBFF000, 0x00001000)
>                         Memory32Fixed (ReadWrite, 0xFEC00000, 0x00001000)
>                     })
>                 }

>                 Device (FWHD)
>                 {
>                     Name (_HID, EisaId ("INT0800"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         Memory32Fixed (ReadOnly, 0xFF800000, 0x00800000)
>                     })
>                 }

>                 Device (EC0)
>                 {
>                     Name (_HID, EisaId ("PNP0C09"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
>                         IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
>                     })
>                     Name (_GPE, 0x1C)
>                     Name (ECOK, 0x00)
>                     Method (_REG, 2, NotSerialized)
>                     {
>                         If (LEqual (Arg0, 0x03))
>                         {
>                             Store (Arg1, ECOK)
>                         }
>                     }

>                     Name (_PRW, Package (0x02)
>                     {
>                         0x1D, 
>                         0x05
>                     })
>                     OperationRegion (ECR, EmbeddedControl, 0x00, 0xFF)
>                     Field (ECR, ByteAcc, Lock, Preserve)
>                     {
>                         Offset (0x80), 
>                         MPBP,   1, 
>                         MPBD,   1, 
>                         DOKD,   1, 
>                         DFBP,   1, 
>                         Offset (0x81), 
>                         BT1A,   1, 
>                         BT2A,   1, 
>                         ACAT,   1, 
>                         Offset (0x82), 
>                         PWRB,   1, 
>                         JOGB,   1, 
>                         LIDS,   1, 
>                         Offset (0x83), 
>                         BT1P,   1, 
>                         BT2P,   1, 
>                         Offset (0x84), 
>                         B1ST,   8, 
>                         B2ST,   8, 
>                         Offset (0x90), 
>                         MASK,   8, 
>                         BT1S,   1, 
>                         BT2S,   1, 
>                         Offset (0x92), 
>                         BT1W,   1, 
>                         BT2W,   1, 
>                         Offset (0x93), 
>                         FAN0,   8, 
>                         CB0S,   1, 
>                         CB1S,   1, 
>                         Offset (0x95), 
>                         PHYO,   1, 
>                         Offset (0x96), 
>                         BRIT,   8, 
>                         CONT,   8, 
>                         SNDU,   1, 
>                         SNDD,   1, 
>                         Offset (0x99), 
>                         SMDM,   1, 
>                         Offset (0x9A), 
>                         Offset (0x9B), 
>                         SIRQ,   8, 
>                         SLOB,   8, 
>                         SHIB,   8, 
>                         MPWR,   1, 
>                         WAKI,   1, 
>                         Offset (0x9F), 
>                         Offset (0xA0), 
>                         B1RC,   16, 
>                         B1AB,   16, 
>                         B1AC,   16, 
>                         B1VO,   16, 
>                         B2RC,   16, 
>                         B2AB,   16, 
>                         B2AC,   16, 
>                         B2VO,   16, 
>                         B1DC,   16, 
>                         B1LF,   16, 
>                         B1DV,   16, 
>                         B1DL,   16, 
>                         B2DC,   16, 
>                         B2LF,   16, 
>                         B2DV,   16, 
>                         B2DL,   16, 
>                         A1TP,   16, 
>                         A1AT,   16, 
>                         A1PT,   16, 
>                         A1CT,   16, 
>                         A2TP,   16, 
>                         A2AT,   16, 
>                         A2PT,   16, 
>                         A2CT,   16
>                     }

>                     Method (_Q50, 0, NotSerialized)
>                     {
>                         Notify (ACAD, 0x80)
>                         \_SB.NCPU ()
>                     }

>                     Method (_Q51, 0, NotSerialized)
>                     {
>                         If (BT1A)
>                         {
>                             Notify (BAT1, 0x00)
>                         }
>                         Else
>                         {
>                             Notify (BAT1, 0x01)
>                         }

>                         Notify (BAT1, 0x80)
>                     }

>                     Method (_Q53, 0, NotSerialized)
>                     {
>                         Store ("_Q53:Battery Selection", Debug)
>                     }

>                     Method (_Q58, 0, NotSerialized)
>                     {
>                         Store ("_Q58:ATF temperature trip point changd", Debug)
>                         Notify (\_TZ.ATF0, 0x81)
>                     }

>                     Method (_Q5F, 0, NotSerialized)
>                     {
>                         Store ("_Q5F:ATF temperature reaches trip point", Debug)
>                         Notify (\_TZ.ATF0, 0x80)
>                     }

>                     Method (_Q60, 0, NotSerialized)
>                     {
>                         Notify (\_SB.PWRB, 0x80)
>                     }

>                     Method (_Q66, 0, NotSerialized)
>                     {
>                         Notify (\_SB.LID0, 0x80)
>                     }

>                     Device (BAT1)
>                     {
>                         Name (_HID, EisaId ("PNP0C0A"))
>                         Name (_UID, 0x01)
>                         Name (_PCL, Package (0x01)
>                         {
>                             \_SB
>                         })
>                         Name (BATI, Package (0x0D)
>                         {
>                             0x00, 
>                             0x9650, 
>                             0x9650, 
>                             0x00, 
>                             0x39D0, 
>                             0x00, 
>                             0x78, 
>                             0x00, 
>                             0x0A, 
>                             "", 
>                             "", 
>                             "LION", 
>                             "Sony Corp."
>                         })
>                         Name (BATS, Package (0x04)
>                         {
>                             0x02, 
>                             0xFFFFFFFF, 
>                             0x0D7A, 
>                             0x3840
>                         })
>                         Method (_STA, 0, NotSerialized)
>                         {
>                             If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                             {
>                                 And (PHSD (0xD4, 0x80), 0x0100, Local1)
>                             }
>                             Else
>                             {
>                                 Store (BT1A, Local1)
>                             }

>                             If (Local1)
>                             {
>                                 Store (0x1F, Local0)
>                             }
>                             Else
>                             {
>                                 Store (0x0F, Local0)
>                             }

>                             Return (Local0)
>                         }

>                         Method (_BIF, 0, NotSerialized)
>                         {
>                             If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                             {
>                                 Store (PHSD (0xD4, 0xB0), Local0)
>                                 Store (PHSD (0xD4, 0xB2), Local1)
>                                 Store (PHSD (0xD4, 0xB6), Local2)
>                             }
>                             Else
>                             {
>                                 Store (B1DC, Local0)
>                                 Store (B1LF, Local1)
>                                 Store (B1DV, Local2)
>                             }

>                             Multiply (Local0, 0x0A, Index (BATI, 0x01))
>                             Multiply (Local1, 0x0A, Index (BATI, 0x02))
>                             Store (Local2, Index (BATI, 0x04))
>                             Return (BATI)
>                         }

>                         Method (_BST, 0, NotSerialized)
>                         {
>                             If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                             {
>                                 Store (And (PHSD (0xD4, 0x84), 0xFF, Local0), Index (BATS, 0x00))
>                                 Store (PHSD (0xD4, 0xA6), Local0)
>                                 Store (PHSD (0xD4, 0xA4), Local1)
>                                 Store (PHSD (0xD4, 0xA2), Local2)
>                             }
>                             Else
>                             {
>                                 Store (B1ST, Index (BATS, 0x00))
>                                 Store (B1VO, Local0)
>                                 Store (B1AC, Local1)
>                                 Store (B1AB, Local2)
>                             }

>                             If (LEqual (Local1, 0xFFFF))
>                             {
>                                 Store (0xFFFFFFFF, Local1)
>                             }
>                             Else
>                             {
>                                 If (LNot (LLess (Local1, 0x8000)))
>                                 {
>                                     XOr (Local1, 0xFFFF, Local1)
>                                     Increment (Local1)
>                                 }

>                                 Multiply (Local0, Local1, Local1)
>                                 Divide (Local1, 0x03E8, , Local1)
>                             }

>                             Store (Local1, Index (BATS, 0x01))
>                             Multiply (Local2, 0x0A, Index (BATS, 0x02))
>                             Store (Local0, Index (BATS, 0x03))
>                             Return (BATS)
>                         }
>                     }

>                     Scope (\)
>                     {
>                         Name (PWRS, Ones)
>                     }

>                     Device (ACAD)
>                     {
>                         Name (_HID, "ACPI0003")
>                         Name (_PCL, Package (0x01)
>                         {
>                             \_SB
>                         })
>                         Method (_PSR, 0, NotSerialized)
>                         {
>                             If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                             {
>                                 And (PHSD (0xD4, 0x80), 0x0400, Local1)
>                             }
>                             Else
>                             {
>                                 Store (ACAT, Local1)
>                             }

>                             Store (Local1, PWRS)
>                             If (Local1)
>                             {
>                                 Return (One)
>                             }
>                             Else
>                             {
>                                 Return (Zero)
>                             }
>                         }

>                         Method (_STA, 0, NotSerialized)
>                         {
>                             Return (0x0F)
>                         }
>                     }
>                 }

>                 Device (SPIC)
>                 {
>                     Name (_HID, EisaId ("SNY6001"))
>                     Name (RSRC, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
>                         IRQNoFlags () {}
>                     })
>                     Name (SSRC, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
>                         IRQNoFlags () {}
>                     })
>                     Name (SIRT, Package (0x04)
>                     {
>                         0x06, 
>                         0x09, 
>                         0x0A, 
>                         0x0B
>                     })
>                     Method (_CRS, 0, NotSerialized)
>                     {
>                         CreateByteField (RSRC, 0x02, IOM1)
>                         CreateByteField (RSRC, 0x03, IOM2)
>                         CreateWordField (RSRC, 0x02, IO1I)
>                         CreateWordField (RSRC, 0x04, IO1A)
>                         CreateWordField (RSRC, 0x09, IRQV)
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             Store (PHSB (0xD4, 0x9C), IOM1)
>                             Store (PHSB (0xD4, 0x9D), IOM2)
>                         }
>                         Else
>                         {
>                             Store (\_SB.PCI0.LPCB.EC0.SLOB, IOM1)
>                             Store (\_SB.PCI0.LPCB.EC0.SHIB, IOM2)
>                         }

>                         Store (IO1I, IO1A)
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             ShiftRight (PHSB (0xD4, 0x9B), 0x04, Local0)
>                         }
>                         Else
>                         {
>                             ShiftRight (\_SB.PCI0.LPCB.EC0.SIRQ, 0x04, Local0)
>                         }

>                         FindSetRightBit (Local0, Local1)
>                         If (Local1)
>                         {
>                             Decrement (Local1)
>                             Store (DerefOf (Index (SIRT, Local1)), Local0)
>                             ShiftLeft (0x01, Local0, IRQV)
>                         }

>                         Return (RSRC)
>                     }

>                     Method (_SRS, 1, NotSerialized)
>                     {
>                         CreateByteField (Arg0, 0x02, IOA1)
>                         CreateByteField (Arg0, 0x03, IOA2)
>                         CreateWordField (Arg0, 0x09, IRQV)
>                         FindSetRightBit (IRQV, Local0)
>                         If (Local0)
>                         {
>                             Decrement (Local0)
>                             Store (Match (SIRT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
>                             ShiftLeft (0x10, Local1, Local2)
>                         }
>                         Else
>                         {
>                             Store (0x00, Local2)
>                         }

>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             PHSW (0xD5, 0x9B, Local2)
>                         }
>                         Else
>                         {
>                             Store (Local2, \_SB.PCI0.LPCB.EC0.SIRQ)
>                         }

>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             PHSW (0xD5, 0x9D, IOA2)
>                             PHSW (0xD5, 0x9C, IOA1)
>                         }
>                         Else
>                         {
>                             Store (IOA2, \_SB.PCI0.LPCB.EC0.SHIB)
>                             Store (IOA1, \_SB.PCI0.LPCB.EC0.SLOB)
>                         }

>                         Sleep (0x01)
>                     }

>                     Name (_PRS, ResourceTemplate ()
>                     {
>                         StartDependentFnNoPri ()
>                         {
>                             IO (Decode16, 0x1080, 0x1080, 0x01, 0x20)
>                         }
>                         StartDependentFnNoPri ()
>                         {
>                             IO (Decode16, 0x10A0, 0x10A0, 0x01, 0x20)
>                         }
>                         StartDependentFnNoPri ()
>                         {
>                             IO (Decode16, 0x10C0, 0x10C0, 0x01, 0x20)
>                         }
>                         StartDependentFnNoPri ()
>                         {
>                             IO (Decode16, 0x10E0, 0x10E0, 0x01, 0x20)
>                         }
>                         EndDependentFn ()
>                         IRQNoFlags () {6,9,10,11}
>                     })
>                     Method (_DIS, 0, NotSerialized)
>                     {
>                         Store (_CRS (), SSRC)
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             PHSW (0xD5, 0x9B, 0x00)
>                             PHSW (0xD5, 0x9D, 0x00)
>                             PHSW (0xD5, 0x9C, 0x00)
>                         }
>                         Else
>                         {
>                             Store (0x00, \_SB.PCI0.LPCB.EC0.SIRQ)
>                             Store (0x00, \_SB.PCI0.LPCB.EC0.SHIB)
>                             Store (0x00, \_SB.PCI0.LPCB.EC0.SLOB)
>                         }

>                         Sleep (0x01)
>                     }

>                     Method (_STA, 0, NotSerialized)
>                     {
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             ShiftRight (PHSB (0xD4, 0x9B), 0x04, Local0)
>                         }
>                         Else
>                         {
>                             ShiftRight (\_SB.PCI0.LPCB.EC0.SIRQ, 0x04, Local0)
>                         }

>                         FindSetRightBit (Local0, Local1)
>                         If (Local1)
>                         {
>                             Return (0x0F)
>                         }
>                         Else
>                         {
>                             Return (0x0D)
>                         }
>                     }
>                 }

>                 Device (SNC)
>                 {
>                     Name (_HID, EisaId ("SNY5001"))
>                     Method (GPID, 0, NotSerialized)
>                     {
>                         Return (PHSB (0xC0, 0x00))
>                     }

>                     Method (GBRT, 0, NotSerialized)
>                     {
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             Store (PHSD (0xD4, 0x96), Local0)
>                         }
>                         Else
>                         {
>                             Store (\_SB.PCI0.LPCB.EC0.BRIT, Local0)
>                         }

>                         Return (PHSB (0xCF, Local0))
>                     }

>                     Method (SBRT, 1, NotSerialized)
>                     {
>                         Store (PHSB (0xCD, Arg0), Local0)
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             PHSB (0xC3, Local0)
>                         }
>                         Else
>                         {
>                             Store (Local0, \_SB.PCI0.LPCB.EC0.BRIT)
>                         }

>                         Return (Zero)
>                     }

>                     Method (GPBR, 0, NotSerialized)
>                     {
>                         Return (PHSB (0xC1, 0x00))
>                     }

>                     Method (SPBR, 1, NotSerialized)
>                     {
>                         PHSB (0xC2, Arg0)
>                         Return (Zero)
>                     }

>                     Method (GCTR, 0, NotSerialized)
>                     {
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             Store (PHSD (0xD4, 0x97), Local0)
>                         }
>                         Else
>                         {
>                             Store (\_SB.PCI0.LPCB.EC0.CONT, Local0)
>                         }

>                         Return (PHSB (0xD0, Local0))
>                     }

>                     Method (SCTR, 1, NotSerialized)
>                     {
>                         Store (PHSB (0xCE, Arg0), Local0)
>                         If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
>                         {
>                             PHSB (0xC6, Local0)
>                         }
>                         Else
>                         {
>                             Store (Local0, \_SB.PCI0.LPCB.EC0.CONT)
>                         }

>                         Return (Zero)
>                     }

>                     Method (GPCR, 0, NotSerialized)
>                     {
>                         Return (PHSB (0xC4, 0x00))
>                     }

>                     Method (SPCR, 1, NotSerialized)
>                     {
>                         PHSB (0xC5, Arg0)
>                         Return (Zero)
>                     }

>                     Method (GCMI, 1, NotSerialized)
>                     {
>                         Return (PHSD (0xCA, Arg0))
>                     }

>                     Method (SCMI, 1, NotSerialized)
>                     {
>                         Return (PHSD (0xCB, Arg0))
>                     }

>                     Method (PWAK, 0, NotSerialized)
>                     {
>                         Acquire (PLOK, 0xFFFF)
>                         Notify (\_PR.CPU0, 0x80)
>                         Release (PLOK)
>                         Return (Zero)
>                     }

>                     Method (PWRN, 0, NotSerialized)
>                     {
>                         Notify (\_SB.PWRB, 0x80)
>                     }

>                     Method (CSXB, 1, NotSerialized)
>                     {
>                         Acquire (MPHS, 0xFFFF)
>                         Store (Arg0, SXBF)
>                         PHS0 (0xCC)
>                         Store (SXBF, Local0)
>                         Release (MPHS)
>                         Return (Local0)
>                     }

>                     Name (BSIT, 0xFFFF)
>                     Method (CDPW, 1, Serialized)
>                     {
>                         If (Arg0)
>                         {
>                             If (LNot (And (\GL03, 0x08)))
>                             {
>                                 Or (And (\_SB.PCI0.IDEC.ICR4, 0x03), 0x04, \_SB.PCI0.IDEC.ICR4)
>                                 Sleep (0x0A)
>                                 Or (\GL03, 0x08, \GL03)
>                                 Sleep (0x01F4)
>                                 And (\_SB.PCI0.IDEC.ICR4, 0x03, \_SB.PCI0.IDEC.ICR4)
>                                 Store (BSIT, \_SB.PCI0.IDEC.SECT)
>                             }
>                         }
>                         Else
>                         {
>                             If (And (\GL03, 0x08))
>                             {
>                                 Store (\_SB.PCI0.IDEC.SECT, BSIT)
>                                 Store (0x8000, \_SB.PCI0.IDEC.SECT)
>                                 Or (And (\_SB.PCI0.IDEC.ICR4, 0x03), 0x04, \_SB.PCI0.IDEC.ICR4)
>                                 Sleep (0x0A)
>                                 And (\GL03, 0xF7, \GL03)
>                                 Sleep (0x01F4)
>                             }
>                         }
>                     }

>                     Method (GCDP, 0, NotSerialized)
>                     {
>                         Return (ShiftRight (And (\GL03, 0x08), 0x03))
>                     }

>                     Method (GWDP, 0, NotSerialized)
>                     {
>                         Return (PHS (0xDF))
>                     }

>                     Method (NPPC, 1, NotSerialized)
>                     {
>                         Noop
>                     }
>                 }

>                 Device (PS2K)
>                 {
>                     Name (_HID, EisaId ("PNP0303"))
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
>                         IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
>                         IRQ (Edge, ActiveHigh, Exclusive) {1}
>                     })
>                 }

>                 Device (PS2M)
>                 {
>                     Name (_HID, EisaId ("SNY9006"))
>                     Name (_CID, 0x130FD041)
>                     Name (_CRS, ResourceTemplate ()
>                     {
>                         IRQ (Edge, ActiveHigh, Exclusive) {12}
>                     })
>                 }
>             }

>             Device (USB0)
>             {
>                 Name (_ADR, 0x001D0000)
>                 OperationRegion (U0CS, PCI_Config, 0xC4, 0x04)
>                 Field (U0CS, DWordAcc, NoLock, Preserve)
>                 {
>                     U0EN,   2
>                 }

>                 Name (_PRW, Package (0x02)
>                 {
>                     0x03, 
>                     0x03
>                 })
>                 Method (_PSW, 1, NotSerialized)
>                 {
>                     If (Arg0)
>                     {
>                         Store (0x03, U0EN)
>                     }
>                     Else
>                     {
>                         Store (0x00, U0EN)
>                     }
>                 }

>                 Method (_S1D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }

>                 Method (_S3D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }

>                 Method (_S4D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }
>             }

>             Device (USB1)
>             {
>                 Name (_ADR, 0x001D0001)
>                 OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)
>                 Field (U1CS, DWordAcc, NoLock, Preserve)
>                 {
>                     U1EN,   2
>                 }

>                 Name (_PRW, Package (0x02)
>                 {
>                     0x04, 
>                     0x03
>                 })
>                 Method (_PSW, 1, NotSerialized)
>                 {
>                     If (Arg0)
>                     {
>                         Store (0x03, U1EN)
>                     }
>                     Else
>                     {
>                         Store (0x00, U1EN)
>                     }
>                 }

>                 Method (_S1D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }

>                 Method (_S3D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }

>                 Method (_S4D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }
>             }

>             Device (USB2)
>             {
>                 Name (_ADR, 0x001D0002)
>                 OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
>                 Field (U2CS, DWordAcc, NoLock, Preserve)
>                 {
>                     U2EN,   2
>                 }

>                 Name (_PRW, Package (0x02)
>                 {
>                     0x0C, 
>                     0x03
>                 })
>                 Method (_PSW, 1, NotSerialized)
>                 {
>                     If (Arg0)
>                     {
>                         Store (0x03, U2EN)
>                     }
>                     Else
>                     {
>                         Store (0x00, U2EN)
>                     }
>                 }

>                 Method (_S1D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }

>                 Method (_S3D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }

>                 Method (_S4D, 0, NotSerialized)
>                 {
>                     Return (0x02)
>                 }
>             }

>             Device (USB7)
>             {
>                 Name (_ADR, 0x001D0007)
>                 Name (_PRW, Package (0x02)
>                 {
>                     0x0D, 
>                     0x03
>                 })
>             }

>             Name (NATA, Package (0x01)
>             {
>                 0x001F0001
>             })
>             Device (IDEC)
>             {
>                 Name (_ADR, 0x001F0001)
>                 OperationRegion (IDEC, PCI_Config, 0x40, 0x18)
>                 Field (IDEC, DWordAcc, NoLock, Preserve)
>                 {
>                     PRIT,   16, 
>                     SECT,   16, 
>                     PSIT,   4, 
>                     SSIT,   4, 
>                     Offset (0x08), 
>                     SYNC,   4, 
>                     Offset (0x0A), 
>                     SDT0,   2, 
>                         ,   2, 
>                     SDT1,   2, 
>                     Offset (0x0B), 
>                     SDT2,   2, 
>                         ,   2, 
>                     SDT3,   2, 
>                     Offset (0x14), 
>                     ICR0,   4, 
>                     ICR1,   4, 
>                     ICR2,   4, 
>                     ICR3,   4, 
>                     ICR4,   4, 
>                     ICR5,   4
>                 }

>                 Device (PRID)
>                 {
>                     Name (_ADR, 0x00)
>                     Method (_GTM, 0, NotSerialized)
>                     {
>                         Name (PBUF, Buffer (0x14)
>                         {
>                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
>                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
>                             0x00, 0x00, 0x00, 0x00
>                         })
>                         CreateDWordField (PBUF, 0x00, PIO0)
>                         CreateDWordField (PBUF, 0x04, DMA0)
>                         CreateDWordField (PBUF, 0x08, PIO1)
>                         CreateDWordField (PBUF, 0x0C, DMA1)
>                         CreateDWordField (PBUF, 0x10, FLAG)
>                         Store (GETP (PRIT), PIO0)
>                         Store (GDMA (And (SYNC, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0, And (ICR1, 0x01)), DMA0)
>                         If (LEqual (DMA0, 0xFFFFFFFF))
>                         {
>                             Store (PIO0, DMA0)
>                         }

>                         If (And (PRIT, 0x4000))
>                         {
>                             If (LEqual (And (PRIT, 0x90), 0x80))
>                             {
>                                 Store (0x0384, PIO1)
>                             }
>                             Else
>                             {
>                                 Store (GETT (PSIT), PIO1)
>                             }
>                         }
>                         Else
>                         {
>                             Store (0xFFFFFFFF, PIO1)
>                         }

>                         Store (GDMA (And (SYNC, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1, And (ICR1, 0x02)), DMA1)
>                         If (LEqual (DMA1, 0xFFFFFFFF))
>                         {
>                             Store (PIO1, DMA1)
>                         }

>                         Store (GETF (And (SYNC, 0x01), And (SYNC, 0x02), PRIT), FLAG)
>                         Return (PBUF)
>                     }

>                     Method (_STM, 3, NotSerialized)
>                     {
>                         CreateDWordField (Arg0, 0x00, PIO0)
>                         CreateDWordField (Arg0, 0x04, DMA0)
>                         CreateDWordField (Arg0, 0x08, PIO1)
>                         CreateDWordField (Arg0, 0x0C, DMA1)
>                         CreateDWordField (Arg0, 0x10, FLAG)
>                         Or (ICR2, 0x04, ICR2)
>                         If (LEqual (SizeOf (Arg1), 0x0200))
>                         {
>                             And (PRIT, 0x40F0, PRIT)
>                             And (SYNC, 0x0E, SYNC)
>                             Store (0x00, SDT0)
>                             And (ICR0, 0x0E, ICR0)
>                             And (ICR1, 0x0E, ICR1)
>                             And (ICR3, 0x0E, ICR3)
>                             And (ICR5, 0x0E, ICR5)
>                             CreateWordField (Arg1, 0x62, W490)
>                             CreateWordField (Arg1, 0x6A, W530)
>                             CreateWordField (Arg1, 0x7E, W630)
>                             CreateWordField (Arg1, 0x80, W640)
>                             CreateWordField (Arg1, 0xB0, W880)
>                             CreateWordField (Arg1, 0xBA, W930)
>                             Or (PRIT, 0x8004, PRIT)
>                             If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
>                             {
>                                 Or (PRIT, 0x02, PRIT)
>                             }

>                             Or (PRIT, SETP (PIO0, W530, W640), PRIT)
>                             If (And (FLAG, 0x01))
>                             {
>                                 Or (SYNC, 0x01, SYNC)
>                                 Store (SDMA (DMA0), SDT0)
>                                 If (LLess (DMA0, 0x1E))
>                                 {
>                                     Or (ICR3, 0x01, ICR3)
>                                 }

>                                 If (LLess (DMA0, 0x3C))
>                                 {
>                                     Or (ICR0, 0x01, ICR0)
>                                 }

>                                 If (And (W930, 0x2000))
>                                 {
>                                     Or (ICR1, 0x01, ICR1)
>                                 }
>                             }
>                         }

>                         If (LEqual (SizeOf (Arg2), 0x0200))
>                         {
>                             And (PRIT, 0x3F0F, PRIT)
>                             Store (0x00, PSIT)
>                             And (SYNC, 0x0D, SYNC)
>                             Store (0x00, SDT1)
>                             And (ICR0, 0x0D, ICR0)
>                             And (ICR1, 0x0D, ICR1)
>                             And (ICR3, 0x0D, ICR3)
>                             And (ICR5, 0x0D, ICR5)
>                             CreateWordField (Arg2, 0x62, W491)
>                             CreateWordField (Arg2, 0x6A, W531)
>                             CreateWordField (Arg2, 0x7E, W631)
>                             CreateWordField (Arg2, 0x80, W641)
>                             CreateWordField (Arg2, 0xB0, W881)
>                             CreateWordField (Arg2, 0xBA, W931)
>                             Or (PRIT, 0x8040, PRIT)
>                             If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
>                             {
>                                 Or (PRIT, 0x20, PRIT)
>                             }

>                             If (And (FLAG, 0x10))
>                             {
>                                 Or (PRIT, 0x4000, PRIT)
>                                 If (LGreater (PIO1, 0xF0))
>                                 {
>                                     Or (PRIT, 0x80, PRIT)
>                                 }
>                                 Else
>                                 {
>                                     Or (PRIT, 0x10, PRIT)
>                                     Store (SETT (PIO1, W531, W641), PSIT)
>                                 }
>                             }

>                             If (And (FLAG, 0x04))
>                             {
>                                 Or (SYNC, 0x02, SYNC)
>                                 Store (SDMA (DMA1), SDT1)
>                                 If (LLess (DMA0, 0x1E))
>                                 {
>                                     Or (ICR3, 0x02, ICR3)
>                                 }

>                                 If (LLess (DMA0, 0x3C))
>                                 {
>                                     Or (ICR0, 0x02, ICR0)
>                                 }

>                                 If (And (W931, 0x2000))
>                                 {
>                                     Or (ICR1, 0x02, ICR1)
>                                 }
>                             }
>                         }
>                     }

>                     Device (P_D0)
>                     {
>                         Name (_ADR, 0x00)
>                         Method (_GTF, 0, NotSerialized)
>                         {
>                             Name (PIB0, Buffer (0x0E)
>                             {
>                                 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
>                                 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
>                             })
>                             CreateByteField (PIB0, 0x01, PMD0)
>                             CreateByteField (PIB0, 0x08, DMD0)
>                             If (And (PRIT, 0x02))
>                             {
>                                 If (LEqual (And (PRIT, 0x09), 0x08))
>                                 {
>                                     Store (0x08, PMD0)
>                                 }
>                                 Else
>                                 {
>                                     Store (0x0A, PMD0)
>                                     ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
>                                     ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
>                                     Add (Local0, Local1, Local2)
>                                     If (LEqual (0x03, Local2))
>                                     {
>                                         Store (0x0B, PMD0)
>                                     }

>                                     If (LEqual (0x05, Local2))
>                                     {
>                                         Store (0x0C, PMD0)
>                                     }
>                                 }
>                             }
>                             Else
>                             {
>                                 Store (0x01, PMD0)
>                             }

>                             If (And (SYNC, 0x01))
>                             {
>                                 Store (Or (SDT0, 0x40), DMD0)
>                                 If (And (ICR1, 0x01))
>                                 {
>                                     If (And (ICR0, 0x01))
>                                     {
>                                         Add (DMD0, 0x02, DMD0)
>                                     }

>                                     If (And (ICR3, 0x01))
>                                     {
>                                         Store (0x45, DMD0)
>                                     }
>                                 }
>                             }
>                             Else
>                             {
>                                 Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
>                             }

>                             Return (PIB0)
>                         }
>                     }

>                     Name (FWSO, "FWSO")
>                     Name (_PSC, 0x00)
>                     Method (_PS0, 0, NotSerialized)
>                     {
>                         Store (0x00, _PSC)
>                     }

>                     Method (_PS3, 0, NotSerialized)
>                     {
>                         Store (0x03, _PSC)
>                     }
>                 }

>                 Device (SECD)
>                 {
>                     Name (_ADR, 0x01)
>                     Method (_GTM, 0, NotSerialized)
>                     {
>                         Name (SBUF, Buffer (0x14)
>                         {
>                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
>                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
>                             0x00, 0x00, 0x00, 0x00
>                         })
>                         CreateDWordField (SBUF, 0x00, PIO0)
>                         CreateDWordField (SBUF, 0x04, DMA0)
>                         CreateDWordField (SBUF, 0x08, PIO1)
>                         CreateDWordField (SBUF, 0x0C, DMA1)
>                         CreateDWordField (SBUF, 0x10, FLAG)
>                         Store (GETP (SECT), PIO0)
>                         Store (GDMA (And (SYNC, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2, And (ICR1, 0x04)), DMA0)
>                         If (LEqual (DMA0, 0xFFFFFFFF))
>                         {
>                             Store (PIO0, DMA0)
>                         }

>                         If (And (SECT, 0x4000))
>                         {
>                             If (LEqual (And (SECT, 0x90), 0x80))
>                             {
>                                 Store (0x0384, PIO1)
>                             }
>                             Else
>                             {
>                                 Store (GETT (SSIT), PIO1)
>                             }
>                         }
>                         Else
>                         {
>                             Store (0xFFFFFFFF, PIO1)
>                         }

>                         Store (GDMA (And (SYNC, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3, And (ICR1, 0x08)), DMA1)
>                         If (LEqual (DMA1, 0xFFFFFFFF))
>                         {
>                             Store (PIO1, DMA1)
>                         }

>                         Store (GETF (And (SYNC, 0x04), And (SYNC, 0x08), SECT), FLAG)
>                         Return (SBUF)
>                     }

>                     Method (_STM, 3, NotSerialized)
>                     {
>                         CreateDWordField (Arg0, 0x00, PIO0)
>                         CreateDWordField (Arg0, 0x04, DMA0)
>                         CreateDWordField (Arg0, 0x08, PIO1)
>                         CreateDWordField (Arg0, 0x0C, DMA1)
>                         CreateDWordField (Arg0, 0x10, FLAG)
>                         Or (ICR2, 0x04, ICR2)
>                         If (LEqual (SizeOf (Arg1), 0x0200))
>                         {
>                             And (SECT, 0x40F0, SECT)
>                             And (SYNC, 0x0B, SYNC)
>                             Store (0x00, SDT2)
>                             And (ICR0, 0x0B, ICR0)
>                             And (ICR1, 0x0B, ICR1)
>                             And (ICR3, 0x0B, ICR3)
>                             And (ICR5, 0x0B, ICR5)
>                             CreateWordField (Arg1, 0x62, W490)
>                             CreateWordField (Arg1, 0x6A, W530)
>                             CreateWordField (Arg1, 0x7E, W630)
>                             CreateWordField (Arg1, 0x80, W640)
>                             CreateWordField (Arg1, 0xB0, W880)
>                             CreateWordField (Arg1, 0xBA, W930)
>                             Or (SECT, 0x8004, SECT)
>                             If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
>                             {
>                                 Or (SECT, 0x02, SECT)
>                             }

>                             Or (SECT, SETP (PIO0, W530, W640), SECT)
>                             If (And (FLAG, 0x01))
>                             {
>                                 Or (SYNC, 0x04, SYNC)
>                                 Store (SDMA (DMA0), SDT2)
>                                 If (LLess (DMA0, 0x1E))
>                                 {
>                                     Or (ICR3, 0x04, ICR3)
>                                 }

>                                 If (LLess (DMA0, 0x3C))
>                                 {
>                                     Or (ICR0, 0x04, ICR0)
>                                 }

>                                 If (And (W930, 0x2000))
>                                 {
>                                     Or (ICR1, 0x04, ICR1)
>                                 }
>                             }
>                         }

>                         If (LEqual (SizeOf (Arg2), 0x0200))
>                         {
>                             And (SECT, 0x3F0F, SECT)
>                             Store (0x00, SSIT)
>                             And (SYNC, 0x07, SYNC)
>                             Store (0x00, SDT3)
>                             And (ICR0, 0x07, ICR0)
>                             And (ICR1, 0x07, ICR1)
>                             And (ICR3, 0x07, ICR3)
>                             And (ICR5, 0x07, ICR5)
>                             CreateWordField (Arg2, 0x62, W491)
>                             CreateWordField (Arg2, 0x6A, W531)
>                             CreateWordField (Arg2, 0x7E, W631)
>                             CreateWordField (Arg2, 0x80, W641)
>                             CreateWordField (Arg2, 0xB0, W881)
>                             CreateWordField (Arg2, 0xBA, W931)
>                             Or (SECT, 0x8040, SECT)
>                             If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
>                             {
>                                 Or (SECT, 0x20, SECT)
>                             }

>                             If (And (FLAG, 0x10))
>                             {
>                                 Or (SECT, 0x4000, SECT)
>                                 If (LGreater (PIO1, 0xF0))
>                                 {
>                                     Or (SECT, 0x80, SECT)
>                                 }
>                                 Else
>                                 {
>                                     Or (SECT, 0x10, SECT)
>                                     Store (SETT (PIO1, W531, W641), SSIT)
>                                 }
>                             }

>                             If (And (FLAG, 0x04))
>                             {
>                                 Or (SYNC, 0x08, SYNC)
>                                 Store (SDMA (DMA1), SDT3)
>                                 If (LLess (DMA0, 0x1E))
>                                 {
>                                     Or (ICR3, 0x08, ICR3)
>                                 }

>                                 If (LLess (DMA0, 0x3C))
>                                 {
>                                     Or (ICR0, 0x08, ICR0)
>                                 }

>                                 If (And (W931, 0x2000))
>                                 {
>                                     Or (ICR1, 0x08, ICR1)
>                                 }
>                             }
>                         }
>                     }

>                     Device (S_D0)
>                     {
>                         Name (_ADR, 0x00)
>                         Method (_GTF, 0, NotSerialized)
>                         {
>                             Name (SIB0, Buffer (0x0E)
>                             {
>                                 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
>                                 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
>                             })
>                             CreateByteField (SIB0, 0x01, PMD0)
>                             CreateByteField (SIB0, 0x08, DMD0)
>                             If (And (SECT, 0x02))
>                             {
>                                 If (LEqual (And (SECT, 0x09), 0x08))
>                                 {
>                                     Store (0x08, PMD0)
>                                 }
>                                 Else
>                                 {
>                                     Store (0x0A, PMD0)
>                                     ShiftRight (And (SECT, 0x0300), 0x08, Local0)
>                                     ShiftRight (And (SECT, 0x3000), 0x0C, Local1)
>                                     Add (Local0, Local1, Local2)
>                                     If (LEqual (0x03, Local2))
>                                     {
>                                         Store (0x0B, PMD0)
>                                     }

>                                     If (LEqual (0x05, Local2))
>                                     {
>                                         Store (0x0C, PMD0)
>                                     }
>                                 }
>                             }
>                             Else
>                             {
>                                 Store (0x01, PMD0)
>                             }

>                             If (And (SYNC, 0x04))
>                             {
>                                 Store (Or (SDT2, 0x40), DMD0)
>                                 If (And (ICR1, 0x04))
>                                 {
>                                     If (And (ICR0, 0x04))
>                                     {
>                                         Add (DMD0, 0x02, DMD0)
>                                     }

>                                     If (And (ICR3, 0x04))
>                                     {
>                                         Store (0x45, DMD0)
>                                     }
>                                 }
>                             }
>                             Else
>                             {
>                                 Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
>                             }

>                             Return (SIB0)
>                         }
>                     }

>                     Method (_PS0, 0, NotSerialized)
>                     {
>                     }

>                     Method (_PS3, 0, NotSerialized)
>                     {
>                     }
>                 }

>                 Method (GETP, 1, Serialized)
>                 {
>                     If (LEqual (And (Arg0, 0x09), 0x00))
>                     {
>                         Return (0xFFFFFFFF)
>                     }

>                     If (LEqual (And (Arg0, 0x09), 0x08))
>                     {
>                         Return (0x0384)
>                     }

>                     ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
>                     ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
>                     Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))))
>                 }

>                 Method (GDMA, 5, Serialized)
>                 {
>                     If (Arg0)
>                     {
>                         If (LAnd (Arg1, Arg4))
>                         {
>                             Return (0x14)
>                         }

>                         If (LAnd (Arg2, Arg4))
>                         {
>                             Return (Multiply (Subtract (0x04, Arg3), 0x0F))
>                         }

>                         Return (Multiply (Subtract (0x04, Arg3), 0x1E))
>                     }

>                     Return (0xFFFFFFFF)
>                 }

>                 Method (GETT, 1, Serialized)
>                 {
>                     Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02), 0x03), And (Arg0, 0x03)))))
>                 }

>                 Method (GETF, 3, Serialized)
>                 {
>                     Name (TMPF, 0x00)
>                     If (Arg0)
>                     {
>                         Or (TMPF, 0x01, TMPF)
>                     }

>                     If (And (Arg2, 0x02))
>                     {
>                         Or (TMPF, 0x02, TMPF)
>                     }

>                     If (Arg1)
>                     {
>                         Or (TMPF, 0x04, TMPF)
>                     }

>                     If (And (Arg2, 0x20))
>                     {
>                         Or (TMPF, 0x08, TMPF)
>                     }

>                     If (And (Arg2, 0x4000))
>                     {
>                         Or (TMPF, 0x10, TMPF)
>                     }

>                     Return (TMPF)
>                 }

>                 Method (SETP, 3, Serialized)
>                 {
>                     If (LGreater (Arg0, 0xF0))
>                     {
>                         Return (0x08)
>                     }
>                     Else
>                     {
>                         If (And (Arg1, 0x02))
>                         {
>                             If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
>                             {
>                                 Return (0x2301)
>                             }

>                             If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
>                             {
>                                 Return (0x2101)
>                             }
>                         }

>                         Return (0x1001)
>                     }
>                 }

>                 Method (SDMA, 1, Serialized)
>                 {
>                     If (LNot (LGreater (Arg0, 0x14)))
>                     {
>                         Return (0x01)
>                     }

>                     If (LNot (LGreater (Arg0, 0x1E)))
>                     {
>                         Return (0x02)
>                     }

>                     If (LNot (LGreater (Arg0, 0x2D)))
>                     {
>                         Return (0x01)
>                     }

>                     If (LNot (LGreater (Arg0, 0x3C)))
>                     {
>                         Return (0x02)
>                     }

>                     If (LNot (LGreater (Arg0, 0x5A)))
>                     {
>                         Return (0x01)
>                     }

>                     Return (0x00)
>                 }

>                 Method (SETT, 3, Serialized)
>                 {
>                     If (And (Arg1, 0x02))
>                     {
>                         If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
>                         {
>                             Return (0x0B)
>                         }

>                         If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
>                         {
>                             Return (0x09)
>                         }
>                     }

>                     Return (0x04)
>                 }
>             }

>             Device (SBUS)
>             {
>                 Name (_ADR, 0x001F0003)
>                 OperationRegion (SBUS, SystemIO, 0x1880, 0x10)
>                 Field (SBUS, ByteAcc, NoLock, Preserve)
>                 {
>                     HSTS,   8, 
>                     Offset (0x02), 
>                     HCON,   8, 
>                     HCOM,   8, 
>                     TXSA,   8, 
>                     DAT0,   8, 
>                     DAT1,   8, 
>                     BDBR,   8, 
>                     Offset (0x09), 
>                     RXSA,   8, 
>                     SDAT,   16
>                 }

>                 Method (SBWB, 3, NotSerialized)
>                 {
>                     Store (0x0A, Local0)
>                     While (LAnd (And (HSTS, 0x01), Local0))
>                     {
>                         Sleep (0x64)
>                         Decrement (Local0)
>                     }

>                     Store (0xFF, HSTS)
>                     Store (Arg0, TXSA)
>                     Store (Arg1, HCOM)
>                     Store (Arg2, DAT0)
>                     Store (0x00, DAT1)
>                     Store (0x08, HCON)
>                     Sleep (0x64)
>                     Store (0x48, HCON)
>                 }

>                 Method (SBRB, 2, NotSerialized)
>                 {
>                     Store (0x0A, Local0)
>                     While (LAnd (And (HSTS, 0x01), Local0))
>                     {
>                         Sleep (0x64)
>                         Decrement (Local0)
>                     }

>                     Store (0xFF, HSTS)
>                     Store (Or (Arg0, 0x01), TXSA)
>                     Store (Arg1, HCOM)
>                     Store (0x08, HCON)
>                     Sleep (0x64)
>                     Store (0x48, HCON)
>                     Store (0x0A, Local0)
>                     While (LAnd (And (HSTS, 0x02), Local0))
>                     {
>                         Sleep (0x64)
>                         Decrement (Local0)
>                     }

>                     Return (DAT0)
>                 }
>             }

>             Device (AUD0)
>             {
>                 Name (_ADR, 0x001F0005)
>             }

>             Device (MODM)
>             {
>                 Name (_ADR, 0x001F0006)
>                 Name (_PRW, Package (0x02)
>                 {
>                     0x05, 
>                     0x03
>                 })
>             }
>         }
>     }

>     Scope (_PR.CPU0)
>     {
>         Method (_PPC, 0, NotSerialized)
>         {
>             If (\_SB.PCI0.LPCB.EC0.ECOK)
>             {
>                 Store (\_SB.PCI0.LPCB.EC0.ACAT, Local0)
>             }
>             Else
>             {
>                 And (\PHSD (0xD4, 0x80), 0x0400, Local0)
>             }

>             If (Local0)
>             {
>                 Return (PSAC)
>             }
>             Else
>             {
>                 Return (PSDC)
>             }
>         }

>         Name (PDC0, 0xF0000000)
>         Method (_PDC, 1, NotSerialized)
>         {
>             CreateDWordField (Arg0, 0x08, CAP0)
>             Store (CAP0, PDC0)
>         }

>         Method (_PCT, 0, NotSerialized)
>         {
>             If (LEqual (And (PDC0, One), One))
>             {
>                 Return (Package (0x02)
>                 {
>                     ResourceTemplate ()
>                     {
>                         Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
>                     }, 

>                     ResourceTemplate ()
>                     {
>                         Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
>                     }
>                 })
>             }
>             Else
>             {
>                 Return (Package (0x02)
>                 {
>                     ResourceTemplate ()
>                     {
>                         Register (SystemIO, 0x10, 0x00, 0x00000000000000B2)
>                     }, 

>                     ResourceTemplate ()
>                     {
>                         Register (SystemIO, 0x08, 0x00, 0x00000000000000B3)
>                     }
>                 })
>             }
>         }

>         Method (_PSS, 0, NotSerialized)
>         {
>             If (LEqual (And (PDC0, One), One))
>             {
>                 Return (NPSS)
>             }
>             Else
>             {
>                 Return (SPSS)
>             }
>         }

>         Name (NPSS, Package (0x06)
>         {
>             Package (0x06)
>             {
>                 0x000006A4, 
>                 0x00005FB4, 
>                 0x0000000A, 
>                 0x0000000A, 
>                 0x00001131, 
>                 0x00001131
>             }, 

>             Package (0x06)
>             {
>                 0x00000578, 
>                 0x00004C2C, 
>                 0x0000000A, 
>                 0x0000000A, 
>                 0x00000E26, 
>                 0x00000E26
>             }, 

>             Package (0x06)
>             {
>                 0x000004B0, 
>                 0x00003E80, 
>                 0x0000000A, 
>                 0x0000000A, 
>                 0x00000C21, 
>                 0x00000C21
>             }, 

>             Package (0x06)
>             {
>                 0x000003E8, 
>                 0x000032C8, 
>                 0x0000000A, 
>                 0x0000000A, 
>                 0x00000A1A, 
>                 0x00000A1A
>             }, 

>             Package (0x06)
>             {
>                 0x00000320, 
>                 0x0000251C, 
>                 0x0000000A, 
>                 0x0000000A, 
>                 0x00000813, 
>                 0x00000813
>             }, 

>             Package (0x06)
>             {
>                 0x00000258, 
>                 0x00001770, 
>                 0x0000000A, 
>                 0x0000000A, 
>                 0x00000610, 
>                 0x00000610
>             }
>         })
>         Name (SPSS, Package (0x06)
>         {
>             Package (0x06)
>             {
>                 0x000006A4, 
>                 0x00005FB4, 
>                 0x00000064, 
>                 0x0000006E, 
>                 0x00000083, 
>                 0x00000000
>             }, 

>             Package (0x06)
>             {
>                 0x00000578, 
>                 0x00004C2C, 
>                 0x00000064, 
>                 0x0000006E, 
>                 0x00000183, 
>                 0x00000001
>             }, 

>             Package (0x06)
>             {
>                 0x000004B0, 
>                 0x00003E80, 
>                 0x00000064, 
>                 0x0000006E, 
>                 0x00000283, 
>                 0x00000002
>             }, 

>             Package (0x06)
>             {
>                 0x000003E8, 
>                 0x000032C8, 
>                 0x00000064, 
>                 0x0000006E, 
>                 0x00000383, 
>                 0x00000003
>             }, 

>             Package (0x06)
>             {
>                 0x00000320, 
>                 0x0000251C, 
>                 0x00000064, 
>                 0x0000006E, 
>                 0x00000483, 
>                 0x00000004
>             }, 

>             Package (0x06)
>             {
>                 0x00000258, 
>                 0x00001770, 
>                 0x00000064, 
>                 0x0000006E, 
>                 0x00000583, 
>                 0x00000005
>             }
>         })
>     }
> }


> nexus0
>   acpi0
>     cpu0 pnpinfo _HID=none _UID=0 at handle=\_PR_.CPU0
>     acpi_tz0 pnpinfo _HID=none _UID=0 at handle=\_TZ_.ATF0
>     acpi_lid0 pnpinfo _HID=PNP0C0D _UID=0 at handle=\_SB_.LID0
>     acpi_button0 pnpinfo _HID=PNP0C0C _UID=0 at handle=\_SB_.PWRB
>     pcib0 pnpinfo _HID=PNP0A03 _UID=0 at handle=\_SB_.PCI0
>       pci0
>         hostb0 pnpinfo vendor=0x8086 device=0x3340 subvendor=0x104d subdevice=0x8140 class=0x060000 at slot=0 function=0
>         pcib1 pnpinfo vendor=0x8086 device=0x3341 subvendor=0x0000 subdevice=0x0000 class=0x060400 at slot=1 function=0 handle=\_SB_.PCI0.AGPB
>           pci1
>             unknown pnpinfo vendor=0x1002 device=0x4c59 subvendor=0x104d subdevice=0x8140 class=0x030000 at slot=0 function=0 handle=\_SB_.PCI0.AGPB.VID0
>         uhci0 pnpinfo vendor=0x8086 device=0x24c2 subvendor=0x104d subdevice=0x8140 class=0x0c0300 at slot=29 function=0 handle=\_SB_.PCI0.USB0
>           usb0
>             uhub0
>         uhci1 pnpinfo vendor=0x8086 device=0x24c4 subvendor=0x104d subdevice=0x8140 class=0x0c0300 at slot=29 function=1 handle=\_SB_.PCI0.USB1
>           usb1
>             uhub1
>               uhub2 pnpinfo vendor=0x0451 product=0x1446 devclass=0x09 devsubclass=0x00 sernum="" at port=0
>                 ukbd0 pnpinfo vendor=0x046e product=0x6782 devclass=0x00 devsubclass=0x00 sernum="" intclass=0x03 intsubclass=0x01 at port=2 interface=0
>                 ums0 pnpinfo vendor=0x046e product=0x6782 devclass=0x00 devsubclass=0x00 sernum="" intclass=0x03 intsubclass=0x01 at port=2 interface=1
>                 ums1 pnpinfo vendor=0x045e product=0x001e devclass=0x00 devsubclass=0x00 sernum="" intclass=0x03 intsubclass=0x01 at port=3 interface=0
>         uhci2 pnpinfo vendor=0x8086 device=0x24c7 subvendor=0x104d subdevice=0x8140 class=0x0c0300 at slot=29 function=2 handle=\_SB_.PCI0.USB2
>           usb2
>             uhub3
>         ehci0 pnpinfo vendor=0x8086 device=0x24cd subvendor=0x104d subdevice=0x8140 class=0x0c0320 at slot=29 function=7 handle=\_SB_.PCI0.USB7
>           usb3
>             uhub4
>               umass1 pnpinfo vendor=0x054c product=0x014d devclass=0x00 devsubclass=0x00 sernum="0052449677492224" intclass=0x08 intsubclass=0x05 at port=4 interface=0
>         pcib2 pnpinfo vendor=0x8086 device=0x2448 subvendor=0x0000 subdevice=0x0000 class=0x060400 at slot=30 function=0 handle=\_SB_.PCI0.PCIB
>           pci2
>             cbb0 pnpinfo vendor=0x1180 device=0x0475 subvendor=0x104d subdevice=0x8140 class=0x060700 at slot=5 function=0 handle=\_SB_.PCI0.PCIB.CRD0
>               cardbus0
>               pccard0
>             fwohci0 pnpinfo vendor=0x1180 device=0x0551 subvendor=0x104d subdevice=0x8140 class=0x0c0010 at slot=5 function=1 handle=\_SB_.PCI0.PCIB.SD94
>               firewire0
>                 sbp0
>             fxp0 pnpinfo vendor=0x8086 device=0x103d subvendor=0x104d subdevice=0x8140 class=0x020000 at slot=8 function=0 handle=\_SB_.PCI0.PCIB.LANC
>               miibus0
>                 inphy0
>             ndis0 pnpinfo vendor=0x8086 device=0x4220 subvendor=0x8086 subdevice=0x2751 class=0x028000 at slot=11 function=0 handle=\_SB_.PCI0.PCIB.WLAN
>         isab0 pnpinfo vendor=0x8086 device=0x24cc subvendor=0x0000 subdevice=0x0000 class=0x060100 at slot=31 function=0 handle=\_SB_.PCI0.LPCB
>           isa0
>             pmtimer0
>             sc0
>             vga0
>             adv0
>             aha0
>             aic0
>             bt0
>             cs0
>             ed0
>             fdc0
>             fe0
>             ie0
>             lnc0
>             pcic0
>             pcic1
>             ppc0
>             sio0
>             sio1
>             sio2
>             sio3
>             sn0
>             vt0
>             orm0
>         atapci0 pnpinfo vendor=0x8086 device=0x24ca subvendor=0x104d subdevice=0x8140 class=0x01018a at slot=31 function=1 handle=\_SB_.PCI0.IDEC
>           ata0
>           ata1
>         unknown pnpinfo vendor=0x8086 device=0x24c3 subvendor=0x104d subdevice=0x8140 class=0x0c0500 at slot=31 function=3 handle=\_SB_.PCI0.SBUS
>         pcm0 pnpinfo vendor=0x8086 device=0x24c5 subvendor=0x104d subdevice=0x8140 class=0x040100 at slot=31 function=5 handle=\_SB_.PCI0.AUD0
>         unknown pnpinfo vendor=0x8086 device=0x24c6 subvendor=0x104d subdevice=0x8140 class=0x070300 at slot=31 function=6 handle=\_SB_.PCI0.MODM
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.AGPB.VID0.CRT_
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.AGPB.VID0.LCD_
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.AGPB.VID0.TV__
>     unknown pnpinfo _HID=PNP0C0F _UID=1 at handle=\_SB_.PCI0.LPCB.LNKA
>     unknown pnpinfo _HID=PNP0C0F _UID=2 at handle=\_SB_.PCI0.LPCB.LNKB
>     unknown pnpinfo _HID=PNP0C0F _UID=3 at handle=\_SB_.PCI0.LPCB.LNKC
>     unknown pnpinfo _HID=PNP0C0F _UID=4 at handle=\_SB_.PCI0.LPCB.LNKD
>     unknown pnpinfo _HID=PNP0C0F _UID=5 at handle=\_SB_.PCI0.LPCB.LNKE
>     unknown pnpinfo _HID=PNP0C0F _UID=6 at handle=\_SB_.PCI0.LPCB.LNKF
>     unknown pnpinfo _HID=PNP0C0F _UID=7 at handle=\_SB_.PCI0.LPCB.LNKG
>     unknown pnpinfo _HID=PNP0C0F _UID=8 at handle=\_SB_.PCI0.LPCB.LNKH
>     attimer0 pnpinfo _HID=PNP0100 _UID=0 at handle=\_SB_.PCI0.LPCB.TIMR
>     atpic0 pnpinfo _HID=PNP0000 _UID=0 at handle=\_SB_.PCI0.LPCB.IPIC
>     attimer1 pnpinfo _HID=PNP0B00 _UID=0 at handle=\_SB_.PCI0.LPCB.RTC_
>     npxisa0 pnpinfo _HID=PNP0C04 _UID=0 at handle=\_SB_.PCI0.LPCB.MATH
>     atdma0 pnpinfo _HID=PNP0200 _UID=0 at handle=\_SB_.PCI0.LPCB.DMAC
>     acpi_sysresource0 pnpinfo _HID=PNP0C02 _UID=0 at handle=\_SB_.PCI0.LPCB.MBRD
>     unknown pnpinfo _HID=INT0800 _UID=0 at handle=\_SB_.PCI0.LPCB.FWHD
>     acpi_ec0 pnpinfo _HID=PNP0C09 _UID=0 at handle=\_SB_.PCI0.LPCB.EC0_
>     acpi_cmbat0 pnpinfo _HID=PNP0C0A _UID=1 at handle=\_SB_.PCI0.LPCB.EC0_.BAT1
>     acpi_acad0 pnpinfo _HID=ACPI0003 _UID=0 at handle=\_SB_.PCI0.LPCB.EC0_.ACAD
>     unknown pnpinfo _HID=SNY6001 _UID=0 at handle=\_SB_.PCI0.LPCB.SPIC
>     unknown pnpinfo _HID=SNY5001 _UID=0 at handle=\_SB_.PCI0.LPCB.SNC_
>     atkbdc0 pnpinfo _HID=PNP0303 _UID=0 at handle=\_SB_.PCI0.LPCB.PS2K
>       atkbd0
>       psm0
>     psmcpnp0 pnpinfo _HID=SNY9006 _UID=0 at handle=\_SB_.PCI0.LPCB.PS2M
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.PRID
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.PRID.P_D0
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.SECD
>     unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.SECD.S_D0
>     acpi_timer0 pnpinfo unknown at unknown
>   legacy0
>   npx0

> _______________________________________________
> freebsd-mobile at freebsd.org mailing list
> http://lists.freebsd.org/mailman/listinfo/freebsd-mobile
> To unsubscribe, send any mail to "freebsd-mobile-unsubscribe at freebsd.org"


-- 
Anton A. Karpov

PGP key:  http://www.toxahost.org/pgp/pubkey.asc
You can finger me @toxahost.org for my current status

=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
Hi! I am a .signature virus!
Copy me into your ~/.signature to help me spread!
=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=


More information about the freebsd-mobile mailing list