Bug 54756

Summary: ACPI suspend/resume problem on CF-W2 laptop
Product: Base System Reporter: youki-k <youki-k>
Component: i386Assignee: Jaakko Heinonen <jh>
Status: Closed FIXED    
Severity: Affects Only Me    
Priority: Normal    
Version: 5.1-CURRENT   
Hardware: Any   
OS: Any   

Description youki-k 2003-07-22 18:00:34 UTC
Suspend/resume does not work correctly on Panasonic CF-W2.
I observed the same symptom on 5.1-CURRENT (yesterday) and 5.1-RELEASE.

"acpiconf -s 3" suspends the machine.  But, when it's resumed, the LCD display
remains blank.  The keyboard is operational so that I can reboot the machine
by typing blindly.

Also, lid-close after acpiconf -s 3 mysteriously resumes the system.

"acpiconf -s 1" produces the following error; it does not suspend.
acpi0: AcpiGetSleepTypeData failed - AE_NOT_FOUND

dmesg, acpidump, sysctl hw.acpi and pciconf -lv output follows.

dmesg output --------------------------------------------------------

Copyright (c) 1992-2003 The FreeBSD Project.
Copyright (c) 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
	The Regents of the University of California. All rights reserved.
FreeBSD 5.1-CURRENT #3: Tue Jul 22 23:59:28 JST 2003
    root@W2.aist-nara.ac.jp:/usr/obj/usr/src/sys/GENERIC
Preloaded elf kernel "/boot/kernel/kernel" at 0xc073d000.
Preloaded elf module "/boot/kernel/acpi.ko" at 0xc073d294.
Timecounter "i8254"  frequency 1193182 Hz
Timecounter "TSC"  frequency 598503332 Hz
CPU: Intel(R) Pentium(R) M processor  900MHz (598.50-MHz 686-class CPU)
  Origin = "GenuineIntel"  Id = 0x695  Stepping = 5
  Features=0xa7e9f9bf<FPU,VME,DE,PSE,TSC,MSR,MCE,CX8,SEP,MTRR,PGE,MCA,CMOV,PAT,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,TM,PBE>
real memory  = 258932736 (246 MB)
avail memory = 243662848 (232 MB)
Pentium Pro MTRR support enabled
npx0: <math processor> on motherboard
npx0: INT 16 interface
acpi0: <PTLTD    RSDT  > on motherboard
pcibios: BIOS version 2.10
Using $PIR table, 8 entries at 0xc00fdf40
acpi0: power button is handled as a fixed feature programming model.
Timecounter "ACPI-fast"  frequency 3579545 Hz
acpi_timer0: <24-bit timer at 3.579545MHz> port 0x1008-0x100b on acpi0
acpi_cpu0: <CPU> on acpi0
acpi_tz0: <thermal zone> on acpi0
pcib0: <ACPI Host-PCI bridge> port 0xcf8-0xcff on acpi0
pci0: <ACPI PCI bus> on pcib0
pcib0: slot 2 INTA is routed to irq 9
pcib0: slot 29 INTA is routed to irq 9
pcib0: slot 29 INTD is routed to irq 11
pcib0: slot 31 INTB is routed to irq 9
pcib0: slot 31 INTB is routed to irq 9
pcib0: slot 31 INTB is routed to irq 9
pci0: <base peripheral> at device 0.1 (no driver attached)
pci0: <base peripheral> at device 0.3 (no driver attached)
agp0: <Intel 8285xM (85xGM GMCH) SVGA controller> port 0x1800-0x1807 mem 0xe0000000-0xe007ffff,0xe8000000-0xefffffff irq 9 at device 2.0 on pci0
agp0: detected 8060k stolen memory
agp0: aperture size is 128M
pci0: <display> at device 2.1 (no driver attached)
uhci0: <Intel 82801DB (ICH4) USB controller USB-A> port 0x1820-0x183f irq 9 at device 29.0 on pci0
usb0: <Intel 82801DB (ICH4) USB controller USB-A> on uhci0
usb0: USB revision 1.0
uhub0: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 2 ports with 2 removable, self powered
pci0: <serial bus, USB> at device 29.7 (no driver attached)
pcib1: <ACPI PCI-PCI bridge> at device 30.0 on pci0
pci1: <ACPI PCI bus> on pcib1
pcib1: slot 1 INTA is routed to irq 3
pcib1: slot 4 INTA is routed to irq 7
pcib1: slot 5 INTB is routed to irq 5
rl0: <RealTek 8139 10/100BaseTX, rev. D> port 0x3000-0x30ff mem 0xe0201000-0xe02010ff irq 3 at device 1.0 on pci1
rl0: Ethernet address: 00:80:45:2b:1e:58
miibus0: <MII bus> on rl0
rlphy0: <RealTek internal media interface> on miibus0
rlphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
pci1: <network> at device 4.0 (no driver attached)
cbb0: <RF5C475 PCI-CardBus Bridge> at device 5.0 on pci1
pcib1: can't decode default resource id 16 for cbb0, bypassing
cardbus0: <CardBus bus> on cbb0
pccard0: <16-bit PCCard bus> on cbb0
pcib1: possible interrupts:  10
pcib1: slot 5 INTA routed to irq 10 via \\_SB_.PCI0.LPC0.LNKG
pci1: <base peripheral> at device 5.1 (no driver attached)
isab0: <PCI-ISA bridge> at device 31.0 on pci0
isa0: <ISA bus> on isab0
atapci0: <Intel ICH4 UDMA100 controller> port 0x1810-0x181f,0-0x3,0-0x7,0-0x3,0-0x7 at device 31.1 on pci0
ata0: at 0x1f0 irq 14 on atapci0
ata1: at 0x170 irq 15 on atapci0
pci0: <serial bus, SMBus> at device 31.3 (no driver attached)
pci0: <multimedia, audio> at device 31.5 (no driver attached)
pci0: <simple comms> at device 31.6 (no driver attached)
acpi_button0: <Power Button> on acpi0
acpi_acad0: <AC adapter> on acpi0
acpi_cmbat0: <Control method Battery> on acpi0
acpi_lid0: <Control Method Lid Switch> on acpi0
acpi_ec0: <embedded controller: GPE 0x1c> port 0x66,0x62 on acpi0
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> flags 0x1 irq 1 on atkbdc0
kbd0 at atkbd0
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: model Generic PS/2 mouse, device ID 0
orm0: <Option ROMs> at iomem 0xe0000-0xeffff,0xdc000-0xdffff,0xc0000-0xcc7ff on isa0
pmtimer0 on isa0
fdc0: ready for input in output
fdc0: cmd 3 failed at out byte 1 of 3
ppc0: parallel port not found.
sc0: <System console> at flags 0x100 on isa0
sc0: VGA <16 virtual consoles, flags=0x300>
sio0: configured irq 4 not in bitmap of probed irqs 0
sio0: port may not be enabled
sio0 at port 0x3f8-0x3ff irq 4 flags 0x10 on isa0
sio0: type 8250 or not responding
sio1: configured irq 3 not in bitmap of probed irqs 0
sio1: port may not be enabled
vga0: <Generic ISA VGA> at port 0x3c0-0x3df iomem 0xa0000-0xbffff on isa0
Timecounters tick every 10.000 msec
acpi_cpu: throttling enabled, 8 steps (100% to 12.5%), currently 100.0%
system power profile changed to 'economy'
cbb0: Unsupported card type detected
ata1-slave: timeout waiting for interrupt
ata1-slave: ATAPI identify failed
ad0: 38154MB <TOSHIBA MK4020GLS> [77520/16/63] at ata0-master UDMA100
acd0: CD-RW <UJDA747 DVD/CDRW> at ata1-master PIO4
Mounting root from ufs:/dev/ad0s2a

acpidump output --------------------------------------------------------

/*
RSD PTR: Checksum=198, OEMID=PTLTD, RsdtAddress=0x0f6f6e87
 */
/*
RSDT: Length=48, Revision=1, Checksum=202,
	OEMID=PTLTD, OEM Table ID=  RSDT, OEM Revision=0x6040000,
	Creator ID= LTP, Creator Revision=0x0
 */
/*
	Entries={ 0x0f6fbf54, 0x0f6fbfd8, 0x0f6f6eb7 }
 */
/*
	DSDT=0xf6f722e
	INT_MODEL=PIC
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
	PM1a_EVT_BLK=0x1000-0x1003
	PM1a_CNT_BLK=0x1004-0x1005
	PM2_CNT_BLK=0x1020-0x1020
	PM2_TMR_BLK=0x1008-0x100b
	PM2_GPE0_BLK=0x1028-0x102f
	P_LVL2_LAT=1ms, P_LVL3_LAT=185ms
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=3
	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4}
 */
/*
DSDT: Length=19750, Revision=1, Checksum=149,
	OEMID=MATBIO, OEM Table ID=CFW2-1, OEM Revision=0x6040000,
	Creator ID=MSFT, Creator Revision=0x100000e
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "MATBIO",		//OEMID
    "CFW2-1",		//TABLE ID
    0x6040000		//OEM Revision
)

{
Scope(_SB_) {
    OperationRegion(SMI0, SystemIO, 0x0000fe00, 0x00000002)
    Field(SMI0, AnyAcc, NoLock, Preserve) {
        SMIC,	8
    }
    OperationRegion(SMI1, SystemMemory, 0x0f6fcd4d, 0x00000200)
    Field(SMI1, AnyAcc, NoLock, Preserve) {
        BCMD,	8,
        DID_,	32,
        INFO,	4056
    }
    Field(SMI1, AnyAcc, NoLock, Preserve) {
        Offset(0x5),
        INF_,	8
    }
    Field(SMI1, AnyAcc, NoLock, Preserve) {
        Offset(0x5),
        INFD,	32
    }
    Field(SMI1, AnyAcc, NoLock, Preserve) {
        Offset(0x5),
        INFP,	128
    }
    Mutex(PSMX, 1)
    Method(PSRV, 5, Serialized) {
        Acquire(PSMX, 0xffff)
        If(Arg2) {
            Store(Arg3, INFO)
        }
        Store(Arg1, DID_)
        Store(Arg0, BCMD)
        Store(0x0, SMIC)
        If(LEqual(Arg4, 0x0)) {
            Store(Zero, Local0)
        }
        Else {
            If(LEqual(Arg4, 0x1)) {
                Store(INF_, Local0)
            }
            Else {
                If(LEqual(Arg4, 0x3)) {
                    Store(INFD, Local0)
                }
                Else {
                    If(LEqual(Arg4, 0x4)) {
                        Store(INFP, Local0)
                    }
                    Else {
                        Store(INFO, Local0)
                    }
                }
            }
        }
        Release(PSMX)
        Return(Local0)
    }
    Method(ECRD, 1) {
        And(Arg0, 0xff, Local0)
        Return(PSRV(0x98, Local0, 0x0, 0x0, 0x1))
    }
    Method(ECER, 1) {
        And(Arg0, 0xff, Local0)
        Return(PSRV(0xb2, Local0, 0x0, 0x0, 0x1))
    }
    Method(ECR2, 1) {
        And(Arg0, 0xff, Local0)
        Return(PSRV(0x9a, Local0, 0x0, 0x0, 0x3))
    }
    Method(ECMD, 3) {
        And(Arg0, 0xff, Local0)
        And(Arg1, 0xff, Local1)
        And(Arg2, 0xff, Local2)
        PSRV(0x99, Add(Add(Local0, ShiftLeft(Local1, 0x8, ), ), ShiftLeft(Local2, 0x10, ), ), 0x0, 0x0, 0x0)
    }
    Method(ECWR, 2) {
        And(Arg0, 0xff, Local0)
        And(Arg1, 0xff, Local1)
        PSRV(0x99, Add(Local0, ShiftLeft(Local1, 0x10, ), ), 0x0, 0x0, 0x0)
    }
    Method(ECEW, 2) {
        And(Arg0, 0xff, Local0)
        PSRV(0xb3, Local0, 0x1, Arg1, 0x0)
    }
    Method(ECW4, 2) {
        And(Arg0, 0xff, Local0)
        PSRV(0xa2, Local0, 0x1, Arg1, 0x0)
    }
    Method(ECW2, 2) {
        And(Arg0, 0xff, Local0)
        PSRV(0xa3, Local0, 0x1, Arg1, 0x0)
    }
    Method(ECRB, 1) {
        Store(\_SB_.ECR2(Arg0), Local0)
        If(And(Local0, 0x8000, )) {
            Or(0xffff0000, Local0, Local0)
        }
        Return(Local0)
    }
    Method(RRTC, 1) {
        And(Arg0, 0xff, Local0)
        Return(PSRV(0x95, 0x5, 0x1, Local0, 0x1))
    }
    Method(DPSX, 2) {
        Or(Arg0, 0x0, Local0)
        Or(Local0, Arg1, Local0)
        PSRV(0x94, Local0, 0x0, 0x0, 0x0)
    }
}
Scope(_SB_) {
    Method(ECPF, 3) {
        If(LEqual(Arg0, 0x0100)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC01())
        }
        If(LEqual(Arg0, 0x0101)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC02(Arg1))
        }
        If(LEqual(Arg0, 0x0110)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC03(Arg1, Arg2))
        }
        If(LEqual(Arg0, 0x0111)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC04(Arg1, Arg2))
        }
        If(LEqual(Arg0, 0x0112)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC05(Arg1, Arg2))
        }
        If(LEqual(Arg0, 0x0200)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC06())
        }
        If(LEqual(Arg0, 0x0201)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC07())
        }
        If(LEqual(Arg0, 0x0202)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC08())
        }
        If(LEqual(Arg0, 0x0203)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC09())
        }
        If(LEqual(Arg0, 0x0204)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC0A())
        }
        If(LEqual(Arg0, 0x0205)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC0B(Arg1))
        }
        If(LEqual(Arg0, 0x0206)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC0C(Arg1))
        }
        If(LEqual(Arg0, 0x0207)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC0D(Arg1))
        }
        If(LEqual(Arg0, 0x0208)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC0E(Arg1))
        }
        If(LEqual(Arg0, 0x0209)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC0F(Arg1))
        }
        If(LEqual(Arg0, 0x020a)) {
            Return(\_SB_.PCI0.LPC0.EC0_.EC10(Arg1, Arg2))
        }
        Return(0xffffffff)
    }
}
Scope(\_SB_) {
    Name(CRUN, Zero)
    Method(CRST) {
        If(CRUN) {
            Store(Zero, \_SB_.PCI0.LPC0.CREN)
        }
        Else {
            Store(One, \_SB_.PCI0.LPC0.CREN)
        }
    }
    Method(CRIN) {
        If(LNot(PSRV(0xb8, Zero, Zero, Zero, One))) {
            Or(CRUN, One, CRUN)
        }
        CRST()
    }
    Method(CRCT, 2) {
        If(Arg1) {
            And(CRUN, Not(Arg0, ), CRUN)
        }
        Else {
            Or(CRUN, Arg0, CRUN)
        }
        CRST()
    }
}
Scope(_PR_) {
    Processor(CPU0, 0, 0x1010, 0x6) {
        Method(_CST) {
            If(\_SB_.PSRV(0xc1, 0x0, 0x0, 0x0, 0x1)) {
                Return(Package(0x5) {
                    0x4,
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x1,
                        0x1,
                        0x03e8,
                    },
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x14, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x2,
                        0x1,
                        0x01f4,
                    },
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x15, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x3,
                        0x55,
                        0xfa,
                    },
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x16, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x3,
                        0xb9,
                        0x64,
                    },
                })
            }
            Else {
                Return(Package(0x4) {
                    0x3,
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x1,
                        0x1,
                        0x03e8,
                    },
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x14, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x2,
                        0x1,
                        0x01f4,
                    },
                    Package(0x4) {
                        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x15, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                        0x3,
                        0x55,
                        0xfa,
                    },
                })
            }
        }
        Name(PDC0, 0x0)
        Method(_PDC, 1) {
            Store(SizeOf(Arg0), Local0)
            Name(PDCB, Buffer(Local0) { })
            Store(Arg0, PDCB)
            CreateDWordField(PDCB, 0x0, REV_)
            CreateDWordField(PDCB, 0x4, SIZE)
            CreateDWordField(PDCB, 0x8, DAT0)
            If(LAnd(LEqual(REV_, 0x1), LGreater(SIZE, 0x0))) {
                If(And(DAT0, 0x1, )) {
                    Store(0x1, PDC0)
                }
            }
        }
        Method(_PCT) {
            If(LEqual(PDC0, 0x1)) {
                Return(Package(0x2) {
                    Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x40, 0x0, 0x0, 0x99, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                    Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x10, 0x0, 0x0, 0x98, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                })
            }
            Else {
                Return(Package(0x2) {
                    Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x10, 0x0, 0x0, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                    Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x80, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                })
            }
        }
        Method(_PPC) {
            Return(0x0)
        }
    }
}
Method(MIN_, 2) {
    If(LLess(Arg0, Arg1)) {
        Return(Arg0)
    }
    Else {
        Return(Arg1)
    }
}
Method(SLEN, 1) {
    Return(SizeOf(Arg0))
}
Method(S2BF, 1, Serialized) {
    Add(SLEN(Arg0), One, Local0)
    Name(BUFF, Buffer(Local0) { })
    Store(Arg0, BUFF)
    Return(BUFF)
}
Method(SCMP, 2) {
    Store(S2BF(Arg0), Local0)
    Store(S2BF(Arg1), Local1)
    Store(Zero, Local4)
    Store(SLEN(Arg0), Local5)
    Store(SLEN(Arg1), Local6)
    Store(MIN_(Local5, Local6), Local7)
    While(LLess(Local4, Local7)) {
        Store(DerefOf(Index(Local0, Local4, )), Local2)
        Store(DerefOf(Index(Local1, Local4, )), Local3)
        If(LGreater(Local2, Local3)) {
            Return(One)
        }
        Else {
            If(LLess(Local2, Local3)) {
                Return(Ones)
            }
        }
        Increment(Local4)
    }
    If(LLess(Local4, Local5)) {
        Return(One)
    }
    Else {
        If(LLess(Local4, Local6)) {
            Return(Ones)
        }
        Else {
            Return(Zero)
        }
    }
}
Name(OSID, 0x0)
Method(CKOS) {
    If(OSID) {
        Return(OSID)
    }
    If(CondRefOf(\_OSI, Local0)) {
        Store(0x82, OSID)
    }
    Else {
        If(LEqual(SCMP(\_OS_, "Microsoft Windows NT"), Zero)) {
            Store(0x81, OSID)
        }
        Else {
            If(LEqual(SCMP(\_OS_, "Microsoft Windows"), Zero)) {
                Store(0x1, OSID)
            }
            Else {
                If(LEqual(SCMP(\_OS_, "Microsoft WindowsME: Millennium Edition"), Zero)) {
                    Store(0x2, OSID)
                }
                Else {
                    Store(0xff, OSID)
                }
            }
        }
    }
    Return(OSID)
}
Scope(\_TZ_) {
    ThermalZone(TZC_) {
        Name(INIT, Zero)
        Name(CSCP, Zero)
        Name(PSV_, 0x0dca)
        Name(CRT_, 0x0e2e)
        Method(INIP) {
            If(LEqual(INIT, Zero)) {
                Store(\_SB_.ECPF(0x0204, Zero, Zero), CRT_)
                Store(\_SB_.ECPF(0x0203, Zero, Zero), PSV_)
                Store(\_SB_.ECPF(0x0202, Zero, Zero), _TC2)
                Store(One, INIT)
            }
        }
        Name(_TC1, Zero)
        Name(_TC2, 0xc)
        Name(_TSP, 0x28)
        Method(_TMP) {
            Store(\_SB_.ECPF(0x0201, Zero, Zero), Local0)
            If(LGreater(Local0, CRT_)) {
                \_SB_.PSRV(0x9c, 0x0, 0x0, 0x0, 0x0)
            }
            Return(Local0)
        }
        Method(_PSV) {
            \_TZ_.TZC_.INIP()
            Return(PSV_)
        }
        Name(_PSL, Package(0x1) {
            \_PR_.CPU0,
        })
        Method(_CRT) {
            \_TZ_.TZC_.INIP()
            Return(CRT_)
        }
        Method(_SCP, 1) {
            Store(Arg0, CSCP)
            Store(Zero, INIT)
            \_TZ_.TZC_.INIP()
            Notify(\_TZ_.TZC_, 0x81)
        }
    }
}
Name(_S0_, Package(0x3) {
    0x0,
    0x0,
    0x0,
})
Name(_S3_, Package(0x3) {
    0x5,
    0x5,
    0x0,
})
Name(_S4_, Package(0x3) {
    0x6,
    0x6,
    0x0,
})
Name(_S5_, Package(0x3) {
    0x7,
    0x7,
    0x0,
})
Name(\_SB_.BAST, 0x0)
Name(FWSO, "FWSO")
Method(_PTS, 1) {
    \_SB_.CRCT(0x2, Zero)
    If(LNot(LEqual(Arg0, 0x5))) {
        \_SB_.PSRV(0x92, 0x2, 0x0, 0x0, 0x0)
    }
    If(LEqual(Arg0, 0x3)) {
        \_SB_.PSRV(0xc7, \_SB_.PCI0.SMDM.MPSW, 0x0, 0x0, 0x0)
        \_SB_.PSRV(0x90, 0x0, 0x1, 0x3, 0x0)
        \_SB_.PSRV(0x91, 0x10, 0x1, 0x1, 0x0)
        \_SB_.PSRV(0x91, 0x40, 0x1, 0x1, 0x0)
    }
    If(LEqual(Arg0, 0x4)) {
        \_SB_.PCI0.IDEC.SVS4()
        \_SB_.PSRV(0x90, 0x0, 0x1, 0x4, 0x0)
    }
    If(LEqual(Arg0, 0x5)) {
        \_SB_.PSRV(0x90, 0x0, 0x1, 0x5, 0x0)
    }
    If(LAnd(LNot(LLess(Arg0, 0x3)), LNot(LGreater(Arg0, 0x5)))) {
        \_SB_.HKEY.HSAV()
    }
    Store(\_SB_.ECPF(0x0101, 0x0, 0x0), \_SB_.BAST)
    \_SB_.ECPF(0x0206, Arg0, 0x0)
}
Method(_WAK, 1) {
    \_SB_.PSRV(0x92, 0x3, 0x1, \CKOS(), 0x0)
    If(LOr(LEqual(Arg0, 0x4), LEqual(Arg0, 0x3))) {
        Store(\_SB_.PSRV(0x93, 0x1, 0x0, 0x0, 0x3), Local0)
        If(LOr(LEqual(Local0, 0x6), LEqual(Local0, 0x1))) {
            Notify(\_SB_.PWRB, 0x2)
        }
    }
    If(LAnd(LNot(LLess(Arg0, 0x3)), LNot(LGreater(Arg0, 0x5)))) {
        \_SB_.HKEY.HRES()
    }
    \_SB_.ECPF(0x0206, 0x0, 0x0)
    Store(\_SB_.ECPF(0x0101, 0x0, 0x0), Local0)
    If(XOr(\_SB_.BAST, Local0, )) {
        If(LEqual(Local0, 0x1)) {
            Notify(\_SB_.BATA, 0x0)
        }
        Else {
            Notify(\_SB_.BATA, 0x1)
        }
        \_SB_.PCI0.LPC0.EC0_._INI()
    }
    \_SB_.CRCT(0x2, One)
    \_SB_.CSTS(0x0)
    Return(Package(0x2) {
        0x0,
        0x0,
    })
}
Scope(\_SI_) {
    Method(_SST, 1) {
        If(LAnd(LNot(LEqual(Arg0, 0x4)), LNot(LEqual(Arg0, 0x0)))) {
            \_SB_.PSRV(0x92, 0x1, 0x1, Arg0, 0x0)
        }
    }
}
Scope(_GPE) {
    Method(_L0B) {
        Notify(\_SB_.PCI0.PCIB, 0x2)
    }
    Method(_L1B) {
        Notify(\_SB_.PWRB, 0x2)
    }
}
Scope(_SB_) {
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_BBN, 0x0)
        Method(_INI) {
            \_SB_.PSRV(0x92, 0x3, 0x1, \CKOS(), 0x0)
        }
        Name(_ADR, 0x0)
        OperationRegion(HBUS, PCI_Config, 0x40, 0xc0)
        Field(HBUS, DWordAcc, NoLock, Preserve) {
            Offset(0x12),
            ,	1,
            IGDP,	1,
            ,	1,
            Offset(0x14),
            ,	7,
            IGDE,	1,
            Offset(0x18),
            ,	7,
            HENA,	1,
            ,	4,
            PM0H,	2,
            Offset(0x1a),
            PM1L,	2,
            ,	2,
            PM1H,	2,
            Offset(0x1b),
            PM2L,	2,
            ,	2,
            PM2H,	2,
            Offset(0x1c),
            PM3L,	2,
            ,	2,
            PM3H,	2,
            Offset(0x1d),
            PM4L,	2,
            ,	2,
            PM4H,	2,
            Offset(0x1e),
            PM5L,	2,
            ,	2,
            PM5H,	2,
            Offset(0x1f),
            PM6L,	2,
            ,	2,
            PM6H,	2
        }
        Name(BUF0, Buffer(0x0201) {0x88, 0xe, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x0, 0x0, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x87, 0x18, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 
 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xc, 0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0xff, 0x3f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x7f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xd, 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0xff, 0x3f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xe, 0x0, 0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0,
  0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xe, 0x0, 0xff, 0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0, 0xff, 0xff, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0xff, 0xff, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc1, 0xfe, 0xff, 0xff, 0xc1, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x79, 0x0 })
        Method(_CRS, 0, Serialized) {
            If(PM1L) {
                CreateDWordField(BUF0, 0x80, C0LN)
                Store(Zero, C0LN)
            }
            If(LEqual(PM1L, 0x1)) {
                CreateBitField(BUF0, 0x0378, C0RW)
                Store(Zero, C0RW)
            }
            If(PM1H) {
                CreateDWordField(BUF0, 0x9b, C4LN)
                Store(Zero, C4LN)
            }
            If(LEqual(PM1H, 0x1)) {
                CreateBitField(BUF0, 0x0450, C4RW)
                Store(Zero, C4RW)
            }
            If(PM2L) {
                CreateDWordField(BUF0, 0xb6, C8LN)
                Store(Zero, C8LN)
            }
            If(LEqual(PM2L, 0x1)) {
                CreateBitField(BUF0, 0x0528, C8RW)
                Store(Zero, C8RW)
            }
            If(PM2H) {
                CreateDWordField(BUF0, 0xd1, CCLN)
                Store(Zero, CCLN)
            }
            If(LEqual(PM2H, 0x1)) {
                CreateBitField(BUF0, 0x0600, CCRW)
                Store(Zero, CCRW)
            }
            If(PM3L) {
                CreateDWordField(BUF0, 0xec, D0LN)
                Store(Zero, D0LN)
            }
            If(LEqual(PM3L, 0x1)) {
                CreateBitField(BUF0, 0x06d8, D0RW)
                Store(Zero, D0RW)
            }
            If(PM3H) {
                CreateDWordField(BUF0, 0x0107, D4LN)
                Store(Zero, D4LN)
            }
            If(LEqual(PM3H, 0x1)) {
                CreateBitField(BUF0, 0x07b0, D4RW)
                Store(Zero, D4RW)
            }
            If(PM4L) {
                CreateDWordField(BUF0, 0x0122, D8LN)
                Store(Zero, D8LN)
            }
            If(LEqual(PM4L, 0x1)) {
                CreateBitField(BUF0, 0x0888, D8RW)
                Store(Zero, D8RW)
            }
            If(PM4H) {
                CreateDWordField(BUF0, 0x013d, DCLN)
                Store(Zero, DCLN)
            }
            If(LEqual(PM4H, 0x1)) {
                CreateBitField(BUF0, 0x0960, DCRW)
                Store(Zero, DCRW)
            }
            If(PM5L) {
                CreateDWordField(BUF0, 0x0158, E0LN)
                Store(Zero, E0LN)
            }
            If(LEqual(PM5L, 0x1)) {
                CreateBitField(BUF0, 0x0a38, E0RW)
                Store(Zero, E0RW)
            }
            If(PM5H) {
                CreateDWordField(BUF0, 0x0173, E4LN)
                Store(Zero, E4LN)
            }
            If(LEqual(PM5H, 0x1)) {
                CreateBitField(BUF0, 0x0b10, E4RW)
                Store(Zero, E4RW)
            }
            If(PM6L) {
                CreateDWordField(BUF0, 0x018e, E8LN)
                Store(Zero, E8LN)
            }
            If(LEqual(PM6L, 0x1)) {
                CreateBitField(BUF0, 0x0be8, E8RW)
                Store(Zero, E8RW)
            }
            If(PM6H) {
                CreateDWordField(BUF0, 0x01a9, ECLN)
                Store(Zero, ECLN)
            }
            If(LEqual(PM6H, 0x1)) {
                CreateBitField(BUF0, 0x0cc0, ECRW)
                Store(Zero, ECRW)
            }
            If(PM0H) {
                CreateDWordField(BUF0, 0x01c4, F0LN)
                Store(Zero, F0LN)
            }
            If(LEqual(PM0H, 0x1)) {
                CreateBitField(BUF0, 0x0d98, F0RW)
                Store(Zero, F0RW)
            }
            CreateDWordField(BUF0, 0x01d3, M1MN)
            CreateDWordField(BUF0, 0x01d7, M1MX)
            CreateDWordField(BUF0, 0x01df, M1LN)
            Multiply(0x02000000, \_SB_.PCI0.MBUS.DRB3, M1MN)
            Add(Subtract(M1MX, M1MN, ), 0x1, M1LN)
            Return(BUF0)
        }
        Device(GMCH) {
            Name(_ADR, 0x0)
            Device(RBAR) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x1000)
                Name(_CRS, Buffer(0xe) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xc1, 0xfe, 0x0, 0x0, 0x1, 0x0, 0x79, 0x0 })
            }
        }
        Device(MBUS) {
            Name(_ADR, 0x1)
            OperationRegion(MBUS, PCI_Config, 0x40, 0xc0)
            Field(MBUS, DWordAcc, NoLock, Preserve) {
                DRB0,	8,
                DRB1,	8,
                DRB2,	8,
                DRB3,	8
            }
        }
        Name(_PRT, Package(0x7) {
            Package(0x4) {
                0x001fffff,
                0x0,
                \_SB_.PCI0.LPC0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x1,
                \_SB_.PCI0.LPC0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x001dffff,
                0x0,
                \_SB_.PCI0.LPC0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x001dffff,
                0x1,
                \_SB_.PCI0.LPC0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x001dffff,
                0x2,
                \_SB_.PCI0.LPC0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x001dffff,
                0x3,
                \_SB_.PCI0.LPC0.LNKH,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x0,
                \_SB_.PCI0.LPC0.LNKA,
                0x0,
            },
        })
        Device(GRFX) {
            Name(_ADR, 0x00020000)
            Name(SSTE, 0x0)
            Name(NSTE, 0x0)
            Name(VCPS, 0x0)
            Method(_PS0) {
                If(LEqual(VCPS, 0x3)) {
                    Sleep(0x01f4)
                }
                DPSX(0x01000000, 0x0)
                Store(0x0, VCPS)
            }
            Method(_PS1) {
                DPSX(0x01000000, 0x1)
                Store(0x1, VCPS)
            }
            Method(_PS2) {
                DPSX(0x01000000, 0x2)
                Store(0x2, VCPS)
            }
            Method(_PS3) {
                DPSX(0x01000000, 0x3)
                Store(0x3, VCPS)
            }
            Method(_DOS, 1) {
                Store(And(Arg0, 0x3, ), Local0)
                \_SB_.PSRV(0xb9, 0x20, 0x1, Local0, 0x0)
            }
            Method(_DOD) {
                Name(BUF3, Package(0x2) {
                    0x00010100,
                    0x00010400,
                })
                Return(BUF3)
            }
            Device(CRT1) {
                Name(_ADR, 0x0100)
                Method(_DCS) {
                    Store(\_SB_.PSRV(0xb9, 0x1, 0x0, 0x0, 0x3), Local0)
                    If(And(Local0, 0x0101, )) {
                        Return(0x1f)
                    }
                    Else {
                        Return(0x1d)
                    }
                }
                Method(_DGS) {
                    Store(NSTE, Local0)
                    If(And(Local0, 0x0101, )) {
                        Return(0x1)
                    }
                    Else {
                        Return(0x0)
                    }
                }
                Method(_DSS, 1) {
                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
                        Store(NSTE, SSTE)
                    }
                }
            }
            Device(LCD1) {
                Name(_ADR, 0x0400)
                Method(_DCS) {
                    Store(\_SB_.PSRV(0xb9, 0x1, 0x0, 0x0, 0x3), Local0)
                    If(And(Local0, 0x0808, )) {
                        Return(0x1f)
                    }
                    Else {
                        Return(0x1d)
                    }
                }
                Method(_DGS) {
                    Store(NSTE, Local0)
                    If(And(Local0, 0x0808, )) {
                        Return(0x1)
                    }
                    Else {
                        Return(0x0)
                    }
                }
                Method(_DSS, 1) {
                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
                        Store(NSTE, SSTE)
                    }
                }
            }
        }
        Device(LPC0) {
            Name(_ADR, 0x001f0000)
            OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
            Field(REGS, DWordAcc, NoLock, Preserve) {
                PMBA,	16,
                Offset(0x18),
                GPBA,	16,
                Offset(0x60),
                ,	2,
                CREN,	1,
                Offset(0x90),
                MTSE,	32,
                Offset(0xb0),
                ,	5,
                FUND,	2
            }
            Method(_INI) {
                \_SB_.CRIN()
            }
            Device(MBRD) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x1f)
                Name(RSRC, Buffer(0xe2) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x1, 0x10, 0x47, 0x1, 0x24, 0x0, 0x24, 0x0, 0x1, 0x2, 0x47, 0x1, 0x28, 0x0, 0x28, 0x0, 0x1, 0x2, 0x47, 0x1, 0x2c, 0x0, 0x2c, 0x0, 0x1, 0x2, 0x47, 0x1, 0x30, 0x0, 0x30, 0x0, 0x1, 0x2, 0x47, 0x1, 0x34, 0x0, 0x34, 0x0, 0x1, 0x2, 0x47, 0x1, 0x38, 0x0, 0x38, 0x0, 0x1, 0x2, 0x47, 0x1, 0x3c, 0x0, 0x3c, 0x0, 0x1, 0x2, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x1, 0x4, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x6, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x1, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0, 0x1, 0x10, 0x47, 0x1, 0xa4, 0x0, 0xa4, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa8, 0x0, 0xa8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xac, 0x0, 0xac, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x6, 0x47, 0x1, 0xb8, 0x0, 0xb8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xbc, 0x0, 0xbc, 0x0, 0x1, 0x2, 0x47, 0x1, 0x0, 0x10, 0x0, 0x10, 0x1, 0x80, 0x47, 0x1, 0x80, 0x11, 0x80, 0x11, 0x1, 0x40, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0x62, 0x3, 0x62, 0x3, 0x1, 0x
 1, 0x47, 0x1, 0x66, 0x3, 0x66, 0x3, 0x1, 0x1, 0x47, 0x1, 0x0, 0xfe, 0x0, 0xfe, 0x2, 0x2, 0x47, 0x1, 0x80, 0x5, 0x80, 0x5, 0x1, 0x8, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x80, 0xff, 0x0, 0x0, 0x80, 0x0, 0x79, 0x0 })
                Method(ISSD, 1) {
                    Store(0x3, Local0)
                    If(And(Arg0, 0x4000, )) {
                        Store(0x30, Local0)
                    }
                    Store(ShiftRight(Subtract(Arg0, 0x000c0000, ), 0xf, ), Local1)
                    If(LEqual(Local1, 0x0)) {
                        Add(Multiply(\_SB_.PCI0.PM1H, 0x10, ), \_SB_.PCI0.PM1L, Local2)
                    }
                    If(LEqual(Local1, 0x1)) {
                        Add(Multiply(\_SB_.PCI0.PM2H, 0x10, ), \_SB_.PCI0.PM2L, Local2)
                    }
                    If(LEqual(Local1, 0x2)) {
                        Add(Multiply(\_SB_.PCI0.PM3H, 0x10, ), \_SB_.PCI0.PM3L, Local2)
                    }
                    If(LEqual(Local1, 0x3)) {
                        Add(Multiply(\_SB_.PCI0.PM4H, 0x10, ), \_SB_.PCI0.PM4L, Local2)
                    }
                    If(LEqual(Local1, 0x4)) {
                        Add(Multiply(\_SB_.PCI0.PM5H, 0x10, ), \_SB_.PCI0.PM5L, Local2)
                    }
                    If(LEqual(Local1, 0x5)) {
                        Add(Multiply(\_SB_.PCI0.PM6H, 0x10, ), \_SB_.PCI0.PM6L, Local2)
                    }
                    Return(And(Local2, Local0, ))
                }
                Method(ROMS, 1) {
                    If(ISSD(Arg0)) {
                        OperationRegion(XROM, SystemMemory, Arg0, 0x4)
                        Field(XROM, ByteAcc, NoLock, Preserve) {
                            SIG_,	16,
                            SIZ_,	8
                        }
                        If(LEqual(SIG_, 0xaa55)) {
                            Return(Multiply(SIZ_, 0x0200, ))
                        }
                    }
                    Return(Zero)
                }
                Name(XBAS, Zero)
                Name(XSIZ, Zero)
                Method(SRCH) {
                    If(LEqual(XBAS, Zero)) {
                        Store(0x000c0000, XBAS)
                        While(LLess(XBAS, 0x000e0000)) {
                            Store(ROMS(XBAS), Local1)
                            Add(XBAS, Local1, XBAS)
                            If(LEqual(Local1, Zero)) {
                                Divide(XBAS, 0x4000, Local2, )
                                If(Local2) {
                                    Subtract(0x4000, Local2, XSIZ)
                                }
                                Return(0x0)
                            }
                        }
                    }
                }
                Method(_CRS) {
                    CreateWordField(RSRC, 0x92, PMMN)
                    CreateWordField(RSRC, 0x94, PMMX)
                    And(^^PMBA, 0xff80, PMMN)
                    Store(PMMN, PMMX)
                    CreateWordField(RSRC, 0x9a, GPMN)
                    CreateWordField(RSRC, 0x9c, GPMX)
                    And(^^GPBA, 0xff80, GPMN)
                    Store(GPMN, GPMX)
                    SRCH()
                    CreateDWordField(RSRC, 0xcc, ROMB)
                    CreateDWordField(RSRC, 0xd0, ROML)
                    Store(XBAS, ROMB)
                    Store(XSIZ, ROML)
                    \_SB_.CSTS(0x0)
                    Return(RSRC)
                }
            }
            Device(DMAC) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0xf, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x1, 0x79, 0x0 })
            }
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0 })
            }
            Device(TIME) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x1, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 0x1, 0x79, 0x0 })
            }
            Device(RTC_) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
            }
            Device(MATH) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x1, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
            }
            Name(\ECST, 0x0)
            Device(EC0_) {
                Name(_HID, 0x090cd041)
                Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x0, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x0, 0x1, 0x79, 0x0 })
                Mutex(ECEX, 0)
                Method(_REG, 2) {
                    If(LEqual(Arg0, 0x3)) {
                        Store(Arg1, ECST)
                    }
                }
                Method(_INI) {
                    INI2()
                }
                Name(_GPE, 0x1c)
                OperationRegion(ECR_, EmbeddedControl, 0x0, 0xff)
                Field(ECR_, ByteAcc, NoLock, Preserve) {
                    BRST,	8,
                    CTRL,	8,
                    Offset(0x4),
                    ECCR,	8,
                    DAT1,	8,
                    DAT2,	8,
                    DAT3,	8,
                    Offset(0x17),
                    SLPT,	8,
                    Offset(0xc0),
                    CPUT,	10
                }
                Method(HCNV, 1, Serialized) {
                    Store(0xffffffff, Local0)
                    If(LAnd(LNot(LLess(Arg0, 0xa)), LNot(LGreater(Arg0, 0x15)))) {
                        Subtract(Arg0, 0x9, Local0)
                        If(And(0x0, ShiftLeft(0x1, Local0, ), )) {
                            Store(0xffffffff, Local0)
                        }
                    }
                    If(LAnd(LNot(LLess(Arg0, 0x70)), LNot(LGreater(Arg0, 0x7b)))) {
                        Add(Arg0, 0x11, Local0)
                        Subtract(Arg0, 0x6f, Local1)
                        If(And(0x0480, ShiftLeft(0x1, Local1, ), )) {
                            Store(0xffffffff, Local0)
                        }
                    }
                    If(LAnd(LNot(LLess(Arg0, 0x81)), LNot(LGreater(Arg0, 0x82)))) {
                        Subtract(Arg0, 0x51, Local0)
                    }
                    If(LNot(LEqual(Local0, 0xffffffff))) {
                        \_SB_.HKEY.HIND(Local0)
                        Notify(\_SB_.HKEY, 0x80)
                    }
                    Else {
                    }
                }
                Method(_Q0A, 0, Serialized) {
                    HCNV(0xa)
                }
                Method(_Q0B, 0, Serialized) {
                    HCNV(0xb)
                }
                Method(_Q0D, 0, Serialized) {
                    HCNV(0xd)
                }
                Method(_Q0E, 0, Serialized) {
                    HCNV(0xe)
                }
                Method(_Q0F, 0, Serialized) {
                    HCNV(0xf)
                }
                Method(_Q10, 0, Serialized) {
                    HCNV(0x10)
                }
                Method(_Q11, 0, Serialized) {
                    HCNV(0x11)
                }
                Method(_Q12, 0, Serialized) {
                    HCNV(0x12)
                }
                Method(_Q13, 0, Serialized) {
                    HCNV(0x13)
                }
                Method(_Q14, 0, Serialized) {
                    HCNV(0x14)
                }
                Method(_Q15, 0, Serialized) {
                    HCNV(0x15)
                }
                Method(_Q70, 0, Serialized) {
                    HCNV(0x70)
                }
                Method(_Q71, 0, Serialized) {
                    HCNV(0x71)
                }
                Method(_Q73, 0, Serialized) {
                    HCNV(0x73)
                }
                Method(_Q74, 0, Serialized) {
                    HCNV(0x74)
                }
                Method(_Q75, 0, Serialized) {
                    HCNV(0x75)
                }
                Method(_Q76, 0, Serialized) {
                    HCNV(0x76)
                }
                Method(_Q77, 0, Serialized) {
                    HCNV(0x77)
                }
                Method(_Q78, 0, Serialized) {
                    HCNV(0x78)
                }
                Method(_Q79, 0, Serialized) {
                    HCNV(0x79)
                }
                Method(_Q7A, 0, Serialized) {
                    HCNV(0x7a)
                }
                Method(_Q7B, 0, Serialized) {
                    HCNV(0x7b)
                }
                Method(_Q81, 0, Serialized) {
                    HCNV(0x81)
                }
                Method(_Q82, 0, Serialized) {
                    HCNV(0x82)
                }
                Method(_Q0C, 0, Serialized) {
                    \_SB_.CHGD()
                }
                Method(_Q72) {
                }
                Method(INI2) {
                }
                Method(_Q23, 0, Serialized) {
                }
                Method(_Q9F, 0, Serialized) {
                    Notify(\_SB_.BATA, 0x81)
                }
                Method(_QA0, 0, Serialized) {
                    Notify(\_SB_.BATA, 0x80)
                }
                Method(EC8D, 1, Serialized) {
                    If(LEqual(ECST, 0x0)) {
                        Store(ShiftLeft(Arg0, 0x8, ), Local0)
                        Store(Add(Local0, 0x88, ), Local0)
                        Store(\_SB_.PSRV(0xc3, Local0, 0x0, 0x0, 0x3), Local0)
                        If(And(Local0, 0xff, )) {
                            Return(0xffffffff)
                        }
                        Else {
                            Store(And(ShiftRight(Local0, 0x8, ), 0xffff, ), Local0)
                            Return(Local0)
                        }
                    }
                    Else {
                        Acquire(ECEX, 0xffff)
                        Store(Arg0, DAT1)
                        Store(0x88, ECCR)
                        Store(0xc8, Local4)
                        While(LAnd(LNot(LEqual(Local4, 0x0)), LNot(LEqual(ECCR, 0x0)))) {
                            Stall(0x19)
                            Decrement(Local4)
                        }
                        Store(DAT1, Local1)
                        Store(DAT2, Local2)
                        Release(ECEX)
                        If(LEqual(Local4, 0x0)) {
                            Return(0xffffffff)
                        }
                        Store(Add(ShiftLeft(Local2, 0x8, ), Local1, ), Local0)
                        Return(Local0)
                    }
                }
                Method(EC03, 2, Serialized) {
                    If(LEqual(Arg1, 0x0)) {
                        If(LEqual(Arg0, 0x0)) {
                            Store(EC86(0x6a), Local0)
                        }
                        If(LEqual(Local0, 0xffffffff)) {
                            Return(0x0)
                        }
                        Else {
                            Return(Local0)
                        }
                    }
                    If(LEqual(Arg1, 0x1)) {
                        If(LEqual(Arg0, 0x0)) {
                            Store(EC8D(0x6c), Local0)
                        }
                        If(LNot(LLess(Local0, 0xffff))) {
                            Return(0xffffffff)
                        }
                        Else {
                            Return(Local0)
                        }
                    }
                    If(LEqual(Arg1, 0x2)) {
                        If(LEqual(Arg0, 0x0)) {
                            Store(EC8D(0x6e), Local0)
                        }
                        If(LNot(LLess(Local0, 0xffff))) {
                            Return(0xffffffff)
                        }
                        Else {
                            Return(Local0)
                        }
                    }
                    If(LEqual(Arg1, 0x3)) {
                        If(LEqual(Arg0, 0x0)) {
                            Store(EC8D(0x70), Local0)
                            EC82(0x41, 0x0)
                        }
                        If(LNot(LLess(Local0, 0xffff))) {
                            Return(0xffffffff)
                        }
                        Else {
                            Return(Local0)
                        }
                    }
                }
                Method(_Q58, 0, Serialized) {
                    Notify(\_TZ_.TZC_, 0x80)
                }
                Method(_Q80, 0, Serialized) {
                    Store(EC01(), Local0)
                    \_SB_.PSRV(0xc4, Local0, 0x0, 0x0, 0x0)
                    Notify(\_SB_.AC__, 0x80)
                }
                Method(_Q83, 0, Serialized) {
                    Notify(\_SB_.LID_, 0x80)
                }
                Method(EC06, 0, Serialized) {
                    Store(0x9, Local0)
                    Store(0x2, Local1)
                    Store(EC89(Local0, Local1), Local2)
                    If(LEqual(Local2, 0xffffffff)) {
                        Return(0x1)
                    }
                    Else {
                        Return(Local2)
                    }
                }
                Method(EC07, 0, Serialized) {
                    Return(EC88(EC87(0x4, 0xc8)))
                }
                Method(EC08, 0, Serialized) {
                    Return(0xc)
                }
                Method(EC09, 0, Serialized) {
                    Return(EC88(EC87(0x4, 0xc5)))
                }
                Method(EC0A, 0, Serialized) {
                    Return(EC88(EC87(0x4, 0xc6)))
                }
                Method(EC0B, 1, Serialized) {
                    EC83(0xb, Arg0)
                    Return(0x0)
                }
                Method(EC01, 0, Serialized) {
                    Return(And(EC86(0x8), 0x1, ))
                }
                Method(EC02, 1, Serialized) {
                    Store(EC86(0x8), Local0)
                    If(LEqual(Local0, 0xffffffff)) {
                        Return(0x0)
                    }
                    If(LEqual(Arg0, 0x0)) {
                        If(And(Local0, 0x4, )) {
                            Return(0x1)
                        }
                        Else {
                            Return(0x0)
                        }
                    }
                }
                Method(EC04, 2, Serialized) {
                    Name(BUF_, Buffer(0x10) { })
                    If(LEqual(Arg0, 0x0)) {
                        If(LEqual(Arg1, 0x0)) {
                            Store(EC85(0x60), Local0)
                            If(LEqual(Local0, 0xffffffff)) {
                                Return(0x1)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x1)) {
                            Store(EC85(0x62), Local0)
                            If(LOr(LEqual(Local0, 0x0), LNot(LLess(Local0, 0xffff)))) {
                                Return(0xffffffff)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x2)) {
                            Store(EC85(0x64), Local0)
                            If(LOr(LEqual(Local0, 0x0), LNot(LLess(Local0, 0xffff)))) {
                                Return(0xffffffff)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x3)) {
                            Return(One)
                        }
                        If(LEqual(Arg1, 0x4)) {
                            Store(EC85(0x68), Local0)
                            If(LOr(LEqual(Local0, 0x0), LNot(LLess(Local0, 0xffff)))) {
                                Return(0xffffffff)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x5)) {
                            Store(EC85(0x72), Local0)
                            If(LEqual(Local0, 0xffffffff)) {
                                Return(0x0)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x6)) {
                            Store(EC85(0x74), Local0)
                            If(LEqual(Local0, 0xffffffff)) {
                                Return(0x0)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x7)) {
                            Store(EC85(0x76), Local0)
                            If(LEqual(Local0, 0xffffffff)) {
                                Return(0x1)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x8)) {
                            Store(EC85(0x78), Local0)
                            If(LEqual(Local0, 0xffffffff)) {
                                Return(0x1)
                            }
                            Else {
                                Return(Local0)
                            }
                        }
                        If(LEqual(Arg1, 0x9)) {
                            Store(0x0, BUF_)
                            Store(EC84(0x8c, 0xc), BUF_)
                            Return(BUF_)
                        }
                        If(LEqual(Arg1, 0xa)) {
                            Store(0x0, BUF_)
                            Store(EC85(0x9a), Local0)
                            Store(EC8C(Local0, 0x5), BUF_)
                            Return(BUF_)
                        }
                        If(LEqual(Arg1, 0xb)) {
                            Store(0x0, BUF_)
                            Store(EC84(0x9c, 0x8), BUF_)
                            Return(BUF_)
                        }
                        If(LEqual(Arg1, 0xc)) {
                            Store("Panasonic", BUF_)
                            Return(BUF_)
                        }
                    }
                }
                Method(EC05, 2, Serialized) {
                    If(LEqual(Arg0, 0x0)) {
                        EC82(0xf0, Arg1)
                    }
                }
                Method(EC0C, 1, Serialized) {
                    Store(And(Arg0, 0x7, ), SLPT)
                    Return(0x0)
                }
                Method(EC0D, 1, Serialized) {
                    If(LEqual(Arg0, 0x1)) {
                        Store(0x98, Local0)
                    }
                    Else {
                        If(LEqual(Arg0, 0x0)) {
                            Store(0x81, Local0)
                        }
                        Else {
                            Return(0xffffffff)
                        }
                    }
                    Return(EC8B(0x43, Local0))
                }
                Method(EC0E, 1, Serialized) {
                    If(LNot(LEqual(EC8A(0x0, 0x23, And(EC87(0x0, 0x23), 0xfd, )), 0x0))) {
                        Return(0xffffffff)
                    }
                    If(LEqual(Arg0, 0x1)) {
                        Store(0x80, Local0)
                    }
                    Else {
                        Store(0x0, Local0)
                    }
                    If(LEqual(EC8A(0x1, 0x9c, 0xff), 0x0)) {
                        Return(EC8A(0x1, 0x9d, Local0))
                    }
                    Else {
                        Return(0xffffffff)
                    }
                }
                Method(EC0F, 1, Serialized) {
                    If(LEqual(Arg0, 0x1)) {
                        Store(0x1, Local0)
                    }
                    Else {
                        If(LEqual(Arg0, 0x0)) {
                            Store(0x0, Local0)
                        }
                        Else {
                            Return(0xffffffff)
                        }
                    }
                    EC83(0x17, Local0)
                    Return(0xffffffff)
                }
                Method(EC10, 2, Serialized) {
                    Store(EC89(Arg0, Arg1), Local0)
                    If(LEqual(Local0, 0xffffffff)) {
                        Return(0x0)
                    }
                    Else {
                        Return(Local0)
                    }
                }
                Method(EC82, 2, Serialized) {
                    If(LEqual(ECST, 0x0)) {
                        If(LAnd(LNot(LLess(Arg0, 0xf0)), LNot(LGreater(Arg0, 0xf3)))) {
                            Store(ShiftLeft(Arg1, 0x8, ), Local0)
                        }
                        Else {
                            Store(0x0, Local0)
                        }
                        Store(Add(ShiftLeft(Local0, 0x8, ), Arg0, ), Local0)
                        Store(Add(ShiftLeft(Local0, 0x8, ), 0xdd, ), Local0)
                        Store(\_SB_.PSRV(0xc3, Local0, 0x0, 0x0, 0x3), Local0)
                        If(And(Local0, 0x400000ff, )) {
                            Return(0xffffffff)
                        }
                        Else {
                            If(LAnd(LNot(LLess(Arg0, 0x20)), LNot(LGreater(Arg0, 0x37)))) {
                                Store(And(ShiftRight(Local0, 0x8, ), 0x0080ffff, ), Local0)
                                Return(Local0)
                            }
                            Else {
                                Return(0x0)
                            }
                        }
                    }
                    Acquire(ECEX, 0xffff)
                    If(LAnd(LNot(LLess(Arg0, 0xf0)), LNot(LGreater(Arg0, 0xf3)))) {
                        Store(And(Arg1, 0xff, ), DAT2)
                        Store(And(ShiftRight(Arg1, 0x8, ), 0xff, ), DAT3)
                    }
                    Store(Arg0, DAT1)
                    Store(0xdd, ECCR)
                    Store(0xc8, Local4)
                    While(LAnd(LNot(LEqual(Local4, 0x0)), LNot(LEqual(ECCR, 0x0)))) {
                        Stall(0x19)
                        Decrement(Local4)
                    }
                    Store(DAT1, Local1)
                    Store(DAT2, Local2)
                    Store(DAT3, Local3)
                    Release(ECEX)
                    If(LOr(LEqual(Local4, 0x0), And(Local3, 0x40, ))) {
                        Return(0xffffffff)
                    }
                    If(LAnd(LNot(LLess(Arg0, 0x20)), LNot(LGreater(Arg0, 0x37)))) {
                        Store(Add(ShiftLeft(Local2, 0x8, ), Local1, ), Local0)
                        If(And(Local3, 0x80, )) {
                            Or(Local0, 0x00800000, )
                        }
                        Return(Local0)
                    }
                    Return(0x0)
                }
                Method(EC83, 2, Serialized) {
                    If(LEqual(ECST, 0x0)) {
                        If(LEqual(Arg0, 0xb)) {
                            \_SB_.ECWR(0xb, Arg1)
                        }
                        If(LEqual(Arg0, 0x17)) {
                            \_SB_.ECWR(0x17, Arg1)
                        }
                    }
                    Else {
                        Acquire(ECEX, 0xffff)
                        Store(Arg0, DAT1)
                        Store(Arg1, DAT2)
                        Store(0xb5, ECCR)
                        Store(0xc8, Local1)
                        While(LAnd(LNot(LEqual(Local1, 0x0)), LNot(LEqual(ECCR, 0x0)))) {
                            Stall(0x19)
                            Decrement(Local1)
                        }
                        Release(ECEX)
                    }
                }
                Method(EC89, 2, Serialized) {
                    If(LOr(LOr(LLess(Arg0, 0x1), LGreater(Arg0, 0x10)), LGreater(Arg1, 0x7))) {
                        Return(0xffffffff)
                    }
                    Store(EC87(0x12, 0xef), Local0)
                    If(LEqual(Local0, 0xffffffff)) {
                        Return(0xffffffff)
                    }
                    Store(0xa, Local1)
                    While(LAnd(LNot(LEqual(Local1, 0x0)), LEqual(EC87(0x12, 0xef), Local0))) {
                        Sleep(0x1)
                        Decrement(Local1)
                    }
                    If(LEqual(Local1, 0x0)) {
                        Return(0xffffffff)
                    }
                    Store(EC87(0x12, Add(0xef, Arg0, )), Local0)
                    If(LEqual(Local0, 0xffffffff)) {
                        Return(0xffffffff)
                    }
                    Return(And(ShiftRight(Local0, Arg1, ), 0x1, ))
                }
                Method(EC84, 2, Serialized) {
                    Name(EBUF, Buffer(0x10) { })
                    Store(0x0, Local0)
                    If(LGreater(Arg1, 0x0)) {
                        While(LLess(Local0, Arg1)) {
                            Store(EC86(Add(Arg0, Local0, )), Local1)
                            If(LEqual(Local1, 0xffffffff)) {
                                Break
                            }
                            Store(Local1, Index(EBUF, Local0, ))
                            Increment(Local0)
                        }
                        If(LNot(LEqual(Local0, Arg1))) {
                            Store(0x0, EBUF)
                        }
                    }
                    Return(EBUF)
                }
                Method(EC85, 1, Serialized) {
                    Add(Arg0, 0x1, Local1)
                    Store(0xffffffff, Local0)
                    If(LNot(LGreater(Local1, 0xff))) {
                        Store(EC86(Local1), Local2)
                        If(LNot(LGreater(Local2, 0xff))) {
                            ShiftLeft(Local2, 0x8, Local2)
                            Store(EC86(Arg0), Local3)
                            If(LNot(LGreater(Local3, 0xff))) {
                                Add(Local3, Local2, Local0)
                            }
                        }
                    }
                    Return(Local0)
                }
                Method(EC86, 1, Serialized) {
                    Store(0xffffffff, Local0)
                    If(LNot(LGreater(Arg0, 0x7f))) {
                        Store(EC87(0x13, Or(Arg0, 0x80, )), Local0)
                    }
                    Else {
                        If(LNot(LGreater(Arg0, 0xff))) {
                            Store(EC87(0x14, Arg0), Local0)
                        }
                    }
                    Return(Local0)
                }
                Method(EC87, 2, Serialized) {
                    If(LEqual(ECST, 0x0)) {
                        Store(Arg0, Local0)
                        Store(Add(ShiftLeft(Local0, 0x8, ), Arg1, ), Local0)
                        Store(Add(ShiftLeft(Local0, 0x10, ), 0xba, ), Local0)
                        Store(\_SB_.PSRV(0xc3, Local0, 0x0, 0x0, 0x3), Local0)
                        If(And(Local0, 0xff, )) {
                            Return(0xffffffff)
                        }
                        Else {
                            Return(And(ShiftRight(Local0, 0x8, ), 0xff, ))
                        }
                    }
                    Acquire(ECEX, 0xffff)
                    Store(0xffffffff, Local0)
                    If(LAnd(LNot(LGreater(Arg1, 0xff)), LNot(LGreater(Arg0, 0x17)))) {
                        Store(Arg1, DAT2)
                        Store(Arg0, DAT3)
                        Store(0xba, ECCR)
                        Store(0xc8, Local1)
                        While(LAnd(LNot(LEqual(Local1, 0x0)), LNot(LEqual(ECCR, 0x0)))) {
                            Stall(0x19)
                            Decrement(Local1)
                        }
                        If(LEqual(Local1, 0x0)) {
                            Store(0xffffffff, Local0)
                        }
                        Else {
                            Store(DAT1, Local0)
                        }
                    }
                    Release(ECEX)
                    Return(Local0)
                }
                Method(EC8B, 2, Serialized) {
                    Store(0xffffffff, Local0)
                    If(LNot(LGreater(Arg0, 0x7f))) {
                        Store(EC8A(0x13, Or(Arg0, 0x80, ), Arg1), Local0)
                    }
                    Else {
                        If(LNot(LGreater(Arg0, 0xff))) {
                            Store(EC8A(0x14, Arg0, Arg1), Local0)
                        }
                    }
                    Return(Local0)
                }
                Method(EC8A, 3, Serialized) {
                    If(LEqual(ECST, 0x0)) {
                        Store(Arg0, Local0)
                        Store(Add(ShiftLeft(Local0, 0x8, ), Arg1, ), Local0)
                        Store(Add(ShiftLeft(Local0, 0x8, ), Arg2, ), Local0)
                        Store(Add(ShiftLeft(Local0, 0x8, ), 0xbb, ), Local0)
                        Store(\_SB_.PSRV(0xc3, Local0, 0x0, 0x0, 0x3), Local0)
                        If(And(Local0, 0xff, )) {
                            Return(0xffffffff)
                        }
                        Else {
                            Return(0x0)
                        }
                    }
                    Acquire(ECEX, 0xffff)
                    Store(0xffffffff, Local0)
                    If(LAnd(LNot(LGreater(Arg1, 0xff)), LNot(LGreater(Arg0, 0x17)))) {
                        Store(Arg2, DAT1)
                        Store(Arg1, DAT2)
                        Store(Arg0, DAT3)
                        Store(0xbb, ECCR)
                        Store(0xc8, Local1)
                        While(LAnd(LNot(LEqual(Local1, 0x0)), LNot(LEqual(ECCR, 0x0)))) {
                            Stall(0x19)
                            Decrement(Local1)
                        }
                        If(LEqual(Local1, 0x0)) {
                            Store(0xffffffff, Local0)
                        }
                        Else {
                            Store(0x0, Local0)
                        }
                    }
                    Release(ECEX)
                    Return(Local0)
                }
                Method(EC88, 1, Serialized) {
                    If(LGreater(Arg0, 0xff)) {
                        Store(0xffffffff, Local0)
                   
Comment 1 Tilman Keskinoz freebsd_committer freebsd_triage 2004-05-20 13:49:00 UTC
Responsible Changed
From-To: freebsd-i386->freebsd-acpi

Over to freebsd-acpi Mailinglist for discussion
Comment 2 Jaakko Heinonen freebsd_committer freebsd_triage 2010-08-20 10:53:43 UTC
State Changed
From-To: open->feedback

Can you still reproduce this on recent FreeBSD versions? 


Comment 3 Jaakko Heinonen freebsd_committer freebsd_triage 2010-08-20 10:53:43 UTC
Responsible Changed
From-To: freebsd-acpi->jh

Track.
Comment 4 Jaakko Heinonen freebsd_committer freebsd_triage 2010-08-20 11:04:28 UTC
State Changed
From-To: feedback->closed

Closed at submitter's request.