Amilo A7600 Suspend/Resume

Evren Yurtesen eyurtese at tekniikka.turkuamk.fi
Sat May 28 15:50:13 PDT 2005


Hi,

I am having a slight problem with my laptop. It just doesnt resume from S3 
state. Standby works with apm only. Suspend doesnt work with anything. 

If I use the DSDT from bios, the laptop reboots when I resume. If I use 
the changed DSDT (which I attached) then laptop comes on but with blank 
screen and everything is frozen.

I am using a custom kernel where I commented out almost everything not 
used (I only let usb/firewire stuff stay) and added sound support.

By the way, the S4 state succesfully resets my bios configuration! I have 
the latest bios from fujitsu :(

How can I debug this problem? Actually I cant even suspend/resume in linux 
but suspend to disk works with ubuntu :p

Any tips? 

Thanks,
Evren
-------------- next part --------------
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20050309
 *
 * Bios 1.10 DSDT Table, modified by Thomas Riedel. 
 * Feel free to improve it, and we need testers for firewire devices 
 * as we do not own any. 
 *
 * Disassembly of dsdt.dat, Wed Mar 16 21:26:15 2005
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "COMPAL", "CY26____", 100925440)
{
    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x00008010, 0x06)
        {
            Method (_PPC, 0, NotSerialized)
            {
                Return (0x00)
            }
        }
    }

    Name (_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x04)
    {
        0x03, 
        0x03, 
        0x00, 
        0x00
    })
    Name (_S4, Package (0x04)
    {
        0x04, 
        0x04, 
        0x00, 
        0x00
    })
    Name (_S5, Package (0x04)
    {
        0x05, 
        0x05, 
        0x00, 
        0x00
    })
    OperationRegion (PORT, SystemIO, 0x80, 0x01)
    Field (PORT, ByteAcc, NoLock, Preserve)
    {
        P80H,   8
    }

    OperationRegion (XCMS, SystemIO, 0x72, 0x02)
    Field (XCMS, ByteAcc, NoLock, Preserve)
    {
        XCM1,   8, 
        XCM2,   8
    }

    IndexField (XCM1, XCM2, ByteAcc, NoLock, Preserve)
    {
        Offset (0x3F), 
        SLPT,   8
    }

    Method (_PTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x04))
        {
            If (\_SB.PCI0.LPCB.EC0.ECOK)
            {
                Store (Arg0, SLPT)
                Store (0x01, \_SB.PCI0.LPCB.EC0.S4S)
            }

            \_SB.PCI0.LPCB.PHSS (0x99)
        }
    }

    Method (_WAK, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x04))
        {
            If (\_SB.PCI0.LPCB.EC0.ECOK)
            {
                Store (0x00, SLPT)
                \_SB.PCI0.LPCB.PHSS (0x98)
            }
        }
// Added the following line in order to suppress a compilation Warning
// I can't swear that it will do something useful
// nor that it will not break something.
// I found that line on a web page about DSDT compilation problems
    Return(Package(0x02){0x00, 0x00})
    }

    Name (ECDY, 0x00)
    Scope (\_SB)
    {
        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                Store ("LID", Debug)
                Return (\_SB.PCI0.PWR.RSM2)
            }
        }

        Mutex (\PSMX, 0x00)
        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Device (PWR)
            {
                Name (_ADR, 0x00060000)
                OperationRegion (PREG, PCI_Config, 0x00, 0x0100)
                Field (PREG, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x80), 
                        ,   6, 
                    ENB1,   1, 
                        ,   6, 
                    THPE,   2, 
                    ENB2,   1, 
                    Offset (0x88), 
                        ,   2, 
                    RSM2,   1
                }
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (0x00, SLPT)
            }

            OperationRegion (BAR1, PCI_Config, 0x14, 0x04)
            Field (BAR1, ByteAcc, NoLock, Preserve)
            {
                Z000,   32
            }

            OperationRegion (MREG, PCI_Config, 0xB8, 0x14)
            Field (MREG, ByteAcc, NoLock, Preserve)
            {
                CS0,    8, 
                CS1,    8, 
                CS2,    8, 
                CS3,    8, 
                Offset (0x10), 
                FBSL,   8, 
                FBSM,   8
            }

            Method (TOM, 0, NotSerialized)
            {
                Multiply (FBSL, 0x00010000, Local0)
                Multiply (FBSM, 0x01000000, Local1)
                Add (Local0, Local1, Local0)
                Return (Local0)
            }

            OperationRegion (VGAM, SystemMemory, 0x000C0002, 0x01)
            Field (VGAM, ByteAcc, Lock, Preserve)
            {
                VSIZ,   8
            }

            Name (RSRC, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, SubDecode,
                    0x0000, // Address Space Granularity
                    0x0000, // Address Range Minimum
                    0x00FF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x0100, 0x00,,)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000, // Address Space Granularity
                    0x000A0000, // Address Range Minimum
                    0x000BFFFF, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0x00020000, 0x00,,
                    , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
                    0x00000000, // Address Space Granularity
                    0x00100000, // Address Range Minimum
                    0xFFFDFFFF, // Address Range Maximum
                    0x00000000, // Address Translation Offset
                    0xFFEE0000, 0x00,,
                    , AddressRangeMemory, TypeStatic)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, // Address Space Granularity
                    0x0000, // Address Range Minimum
                    0x0CF7, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0x0CF8, 0x00,,
                    , TypeStatic)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, // Address Space Granularity
                    0x0D00, // Address Range Minimum
                    0xFFFF, // Address Range Maximum
                    0x0000, // Address Translation Offset
                    0xF300, 0x00,,
                    , TypeStatic)
            })
            Method (_CRS, 0, Serialized)
            {
                CreateDWordField (RSRC, 0x1F, VMAX)
                CreateDWordField (RSRC, 0x27, VLEN)
                ShiftLeft (VSIZ, 0x09, Local0)
                Add (Local0, 0x000BFFFF, VMAX)
                Add (Local0, 0x00020000, VLEN)
                CreateDWordField (RSRC, 0x36, BTMN)
                CreateDWordField (RSRC, 0x3A, BTMX)
                CreateDWordField (RSRC, 0x42, BTLN)
                Store (\_SB.PCI0.TOM (), BTMN)
                Subtract (0xFFF80000, BTMN, BTLN)
                Subtract (Add (BTMN, BTLN), 0x01, BTMX)
                Return (RSRC)
            }

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

            Name (_PRT, Package (0x0A)
            {
                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKU, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0003FFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKG, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKC, 
                    0x00
                }, 

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

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

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

                Package (0x04)
                {
                    0x0010FFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKD, 
                    0x00
                }
            })
            Device (LPCB)
            {
                Name (_ADR, 0x00070000)
                OperationRegion (PUSB, PCI_Config, 0x74, 0x01)
                Field (PUSB, ByteAcc, NoLock, Preserve)
                {
                    PIRU,   4, 
                    Offset (0x01)
                }

                OperationRegion (PIRX, PCI_Config, 0x48, 0x04)
                Field (PIRX, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   4, 
                    PIRB,   4, 
                    PIRC,   4, 
                    PIRD,   4, 
                    PIRE,   4, 
                    PIRF,   4, 
                    PIRG,   4, 
                    PIRH,   4
                }

                Name (IXLT, Package (0x10)
                {
                    0x00, 
                    0x0200, 
                    0x08, 
                    0x0400, 
                    0x10, 
                    0x20, 
                    0x80, 
                    0x40, 
                    0x02, 
                    0x0800, 
                    0x00, 
                    0x1000, 
                    0x00, 
                    0x4000, 
                    0x00, 
                    0x8000
                })
                Device (LNKA) //******** PCMCIA0 (upper slot) ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRA)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
//Bios : IRQ (Level, ActiveLow, Shared) {11} 
//Windows : 11
//Apparently, setting it the same irq as the RADEON (LNKC) solves the 
//conflict between this irq and Radeon irq. 
//I chose irq #3 as it was unused... But this is arbitrary.    
                        IRQ (Level, ActiveLow, Shared) {3}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLA, 0x01, IRQ0)
                        Store (PIRA, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ0)
                        Return (RTLA)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRA)
                    }
                }

                Device (LNKB) //******** ETH0, PCMCIA1 (slot on bottom)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRB)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {11}
// Windows : 11 
// Let's not change anything.        
                        IRQ (Level, ActiveLow, Shared) {11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLB, 0x01, IRQ1)
                        Store (PIRB, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ1)
                        Return (RTLB)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRB)
                    }
                }

                Device (LNKC) //******** FIREWIRE, RADEON ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRC)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {10}
// Windows : 10
// We must choose here the same irq we set for LNKA, otherwise
// the starting of X with DRI activated causes a system freeze 
// Chose irq #3 arbitrarily.        
                        IRQ (Level, ActiveLow, Shared) {3}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLC, 0x01, IRQ2)
                        Store (PIRC, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ2)
                        Return (RTLC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRC)
                    }
                }

                Device (LNKD) // ******** ?????? ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRD)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {10}
// Windows : ?
// Let's not change anything here.        
                        IRQ (Level, ActiveLow, Shared) {10}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLD, 0x01, IRQ3)
                        Store (PIRD, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ3)
                        Return (RTLD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRD)
                    }
                }

                Device (LNKE) //******** USB 1 ********
                              //(1 port, the closest to the left side of the computer)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRE)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {5,9,10,11}
// Windows : 9
// Let's not change anything here.        
                        IRQ (Level, ActiveLow, Shared) {5,9,10,11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLE, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLE, 0x01, IRQ4)
                        Store (PIRE, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ4)
                        Return (RTLE)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRE)
                    }
                }

                Device (LNKF) //******** ?????? ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRF)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {5,9,10,11}
// Windows : ?
// Let's not change anything here.        
                        IRQ (Level, ActiveLow, Shared) {5,9,10,11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLF, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLF, 0x01, IRQ5)
                        Store (PIRF, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ5)
                        Return (RTLF)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRF)
                    }
                }

                Device (LNKG) //******** Modem ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRG)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {5,9,10,11}
// Windows : 11
// Let's not change anything here.        
                        IRQ (Level, ActiveLow, Shared) {5,9,10,11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLG, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLG, 0x01, IRQ6)
                        Store (PIRG, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ6)
                        Return (RTLG)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRG)
                    }
                }

                Device (LNKH) //******** SOUND ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRH)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {5,9,10,11}
// Windows : 9
// Changing not imperative but let's set it to 5 so it has its own IRQ.        
                        IRQ (Level, ActiveLow, Shared) {5}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLH, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLH, 0x01, IRQ7)
                        Store (PIRH, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ7)
                        Return (RTLH)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRH)
                    }
                }

                Device (LNKU) // ******** ACPI, USB0 (2 inner ports) ********
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x09)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRU)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
// Bios : IRQ (Level, ActiveLow, Shared) {9}
// Windows : 9
// Let's not change anything here but a bug is solved later (see comments below)        
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRU)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (RTLU, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLU, 0x01, IRQ8)
                        Store (PIRU, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRQ8)
// "Return(Local0)" is changed to "Return(RTLU)". This solves a bug wich prevented
// the kernel to assign the good irq to USB0 (acpi got always irq #9).
// Here is the kernel (2.4.28) error message : 
//dsmthdat-0462 [39] ds_method_data_get_val: Uninitialized Local[0] at node c14d6d0c
//psparse-1133: *** Error: Method execution failed [\_SB_.PCI0.LPCB.LNKU._CRS] (Node c14dc668), AE_AML_UNINITIALIZED_LOCAL
//uteval-0154: *** Error: Method execution failed [\_SB_.PCI0.LPCB.LNKU._CRS] (Node c14dc668), AE_AML_UNINITIALIZED_LOCAL
//pci_link-0277 [26] acpi_pci_link_get_curr: Error evaluating _CRS
//Samuel Verschelde found the good return value by comparing with the other _CRS functions, for LNKA, LNKB, etc...
                        Return (RTLU)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRU)
                    }
                }

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

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

                Device (TIME)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IRQ (Edge, ActiveHigh, Exclusive) {0}
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x02)
                        IO (Decode16, 0x0072, 0x0072, 0x01, 0x02)
                        IRQ (Edge, ActiveHigh, Exclusive) {8}
                    })
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
                        IRQ (Edge, ActiveHigh, Exclusive) {13}
                    })
                }

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

                Device (KBC0)
                {
                    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 (MSE0)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive) {12}
                    })
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x004E, 0x004E, 0x01, 0x02)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x04)
                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
                        IO (Decode16, 0x0200, 0x0200, 0x01, 0x10)
                        IO (Decode16, 0x040B, 0x040B, 0x01, 0x01)
                        IO (Decode16, 0x0480, 0x0480, 0x01, 0x10)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0x04D6, 0x04D6, 0x01, 0x01)
                        IO (Decode16, 0x8000, 0x8000, 0x01, 0x80)
                        IO (Decode16, 0xFE10, 0xFE10, 0x01, 0x02)
                    })
                }

                Device (MEM)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Name (MSRC, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadWrite, 0x00000000, 0x00000000)
                        Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)
                        Memory32Fixed (ReadOnly, 0x000C0000, 0x0000F000)
                        Memory32Fixed (ReadOnly, 0x000DC000, 0x00004000)
                        Memory32Fixed (ReadOnly, 0x000EC000, 0x00014000)
                        Memory32Fixed (ReadWrite, 0x00100000, 0x07F00000)
                        Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateDWordField (MSRC, 0x04, BARX)
                        CreateDWordField (MSRC, 0x08, GALN)
                        Store (0x1000, GALN)
                        Store (\_SB.PCI0.Z000, Local0)
                        And (Local0, 0xFFFFFFF0, BARX)
                        CreateDWordField (MSRC, 0x44, EMLN)
                        Subtract (\_SB.PCI0.TOM (), 0x00100000, EMLN)
                        Return (MSRC)
                    }

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

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

                OperationRegion (SMI1, SystemMemory, 0x1BEFFE3D, 0x00000100)
                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    BCMD,   8, 
                    DID,    32, 
                    INFO,   1024
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    Offset (0x05), 
                    INF,    8, 
                    INF1,   32
                }

                Mutex (PSMX, 0x00)
                Method (PHSS, 1, NotSerialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x80, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Release (PSMX)
                }

                OperationRegion (SIIO, SystemIO, 0x0370, 0x02)
                Field (SIIO, ByteAcc, NoLock, Preserve)
                {
                    INDX,   8, 
                    DATA,   8
                }

                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x30), 
                    CR30,   8, 
                    Offset (0x60), 
                    CR60,   8, 
                    CR61,   8, 
                    Offset (0x70), 
                    CR70,   8, 
                    Offset (0x74), 
                    CR74,   8, 
                    Offset (0xF0), 
                    CRF0,   8, 
                    CRF1,   8, 
                    CRF2,   8, 
                    Offset (0xF4), 
                    CRF4,   8, 
                    CRF5,   8
                }

                Method (ENFG, 1, NotSerialized)
                {
                    Acquire (MTIO, 0xFFFF)
                    Store (0x51, INDX)
                    Store (0x23, INDX)
                    Store (0x07, INDX)
                    Store (Arg0, DATA)
                }

                Method (EXFG, 0, NotSerialized)
                {
                    Store (0xBB, INDX)
                    Release (MTIO)
                }

                Device (FDC)
                {
                    Name (_HID, EisaId ("PNP0700"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG (0x00)
                        And (CR30, 0x01, Local0)
                        And (CR60, 0x03, Local1)
                        EXFG ()
                        If (LAnd (Local0, Local1))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        \_SB.PCI0.LPCB.COM1.SAVE ()
                        ENFG (0x00)
                        Store (0x00, CR30)
                        Store (0x00, CR60)
                        Store (0x00, CR61)
                        Store (0x00, CR70)
                        Store (0x04, CR74)
                        EXFG ()
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
                        IRQNoFlags () {6}
                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO1L)
                        CreateWordField (RSRC, 0x04, IO1H)
                        CreateWordField (RSRC, 0x0A, IO2L)
                        CreateWordField (RSRC, 0x0C, IO2H)
                        CreateWordField (RSRC, 0x11, IRQX)
                        CreateByteField (RSRC, 0x14, DMAX)
                        Store (Zero, IO1L)
                        Store (Zero, IO1H)
                        Store (Zero, IO2L)
                        Store (Zero, IO2H)
                        Store (Zero, IRQX)
                        Store (Zero, DMAX)
                        ENFG (0x00)
                        Store (CR30, Local0)
                        Store (CR60, Local1)
                        If (LAnd (Local0, Local1))
                        {
                            Store (_PRS, RSRC)
                        }

                        EXFG ()
                        Return (RSRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
                        IRQNoFlags () {6}
                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, RSRC)
                        CreateWordField (RSRC, 0x02, IOX)
                        CreateWordField (RSRC, 0x11, IRQX)
                        CreateByteField (RSRC, 0x14, DMAX)
                        ENFG (0x00)
                        And (IOX, 0xFF, CR61)
                        ShiftRight (IOX, 0x08, CR60)
                        FindSetRightBit (IRQX, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, CR70)
                        FindSetRightBit (DMAX, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, CR74)
                        Store (0x01, CR30)
                        EXFG ()
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        ENFG (0x00)
                        And (CR30, 0x01, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            Return (0x03)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        ENFG (0x00)
                        Store (0x01, CR30)
                        EXFG ()
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        ENFG (0x00)
                        Store (0x00, CR30)
                        EXFG ()
                    }
                }

                Device (LPT)
                {
                    Method (_HID, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        And (CRF0, 0x02, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x0104D041)
                        }
                        Else
                        {
                            Return (0x0004D041)
                        }
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        And (CR30, 0x01, Local0)
                        And (CR60, 0x03, Local1)
                        EXFG ()
                        If (LAnd (Local0, Local1))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        Store (0x00, CR30)
                        Store (0x00, CR60)
                        Store (0x00, CR61)
                        Store (0x00, CR70)
                        Store (0x04, CR74)
                        EXFG ()
                    }

                    Name (CRSA, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
                        IRQNoFlags () {}
                    })
                    Name (CRSB, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
                        IRQNoFlags () {}
                        DMA (Compatibility, NotBusMaster, Transfer8) {}
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (CRSA, 0x02, IOAL)
                        CreateWordField (CRSA, 0x04, IOAH)
                        CreateByteField (CRSA, 0x07, LENA)
                        CreateWordField (CRSA, 0x09, IRAX)
                        Store (Zero, IOAL)
                        Store (Zero, IOAH)
                        Store (Zero, LENA)
                        Store (Zero, IRAX)
                        CreateWordField (CRSB, 0x02, IOBL)
                        CreateWordField (CRSB, 0x04, IOBH)
                        CreateByteField (CRSB, 0x07, LENB)
                        CreateWordField (CRSB, 0x0A, IOCL)
                        CreateWordField (CRSB, 0x0C, IOCH)
                        CreateByteField (CRSB, 0x0F, LENC)
                        CreateWordField (CRSB, 0x11, IRBX)
                        CreateByteField (CRSB, 0x14, DMAX)
                        Store (Zero, IOBL)
                        Store (Zero, IOBH)
                        Store (Zero, LENB)
                        Store (Zero, IOCL)
                        Store (Zero, IOCH)
                        Store (Zero, LENC)
                        Store (Zero, IRBX)
                        Store (Zero, DMAX)
                        ENFG (0x03)
                        Store (CR60, IOAL)
                        ShiftLeft (IOAL, 0x08, Local1)
                        Or (CR61, Local1, Local2)
                        Store (Local2, IOAL)
                        Store (Local2, IOAH)
                        Store (Local2, IOBL)
                        Store (Local2, IOBH)
                        And (CRF0, 0x02, Local0)
                        If (Local0)
                        {
                            Add (Local2, 0x0400, IOCL)
                            Add (Local2, 0x0400, IOCH)
                            If (LEqual (Local2, 0x03BC))
                            {
                                Store (0x04, LENA)
                                Store (0x04, LENB)
                                Store (0x04, LENC)
                            }
                            Else
                            {
                                Store (0x08, LENA)
                                Store (0x08, LENB)
                                Store (0x08, LENC)
                            }
                        }

                        Store (CR70, Local1)
                        ShiftLeft (One, Local1, IRAX)
                        ShiftLeft (One, Local1, IRBX)
                        Store (CR74, Local1)
                        ShiftLeft (One, Local1, DMAX)
                        EXFG ()
                        If (Local0)
                        {
                            Return (CRSB)
                        }
                        Else
                        {
                            Return (CRSA)
                        }
                    }

                    Name (PRSA, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                            IRQNoFlags () {5,7}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                            IRQNoFlags () {5,7}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                            IRQNoFlags () {5,7}
                        }
                        EndDependentFn ()
                    })
                    Name (PRSB, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x08)
                            IRQNoFlags () {5,7}
                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x08)
                            IRQNoFlags () {5,7}
                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
                            IRQNoFlags () {5,7}
                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
                        }
                        EndDependentFn ()
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        And (CRF0, 0x02, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (PRSB)
                        }
                        Else
                        {
                            Return (PRSA)
                        }
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        ENFG (0x03)
                        And (CRF0, 0x02, Local0)
                        If (Local0)
                        {
                            Store (Arg0, CRSB)
                            CreateWordField (CRSB, 0x02, IOB)
                            CreateWordField (CRSB, 0x11, IRQB)
                            CreateByteField (CRSB, 0x14, DMAX)
                            And (IOB, 0xFF, CR61)
                            ShiftRight (IOB, 0x08, CR60)
                            FindSetRightBit (IRQB, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR70)
                            FindSetRightBit (DMAX, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR74)
                        }
                        Else
                        {
                            Store (Arg0, CRSA)
                            CreateWordField (CRSA, 0x02, IOA)
                            CreateWordField (CRSA, 0x09, IRQA)
                            And (IOA, 0xFF, CR61)
                            ShiftRight (IOA, 0x08, CR60)
                            FindSetRightBit (IRQA, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR70)
                        }

                        Store (0x01, CR30)
                        EXFG ()
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        And (CR30, 0x01, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            Return (0x03)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        Store (0x01, CR30)
                        EXFG ()
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        ENFG (0x03)
                        Store (0x00, CR30)
                        EXFG ()
                    }
                }

                Device (COM1)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG (0x04)
                        And (CR30, 0x01, Local0)
                        And (CR60, 0x03, Local1)
                        EXFG ()
                        If (LAnd (Local0, Local1))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG (0x04)
                        Store (0x00, CR30)
                        Store (0x00, CR60)
                        Store (0x00, CR61)
                        Store (0x00, CR70)
                        EXFG ()
                    }

                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                        IRQNoFlags () {4}
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x02, IO1L)
                        CreateWordField (RSRC, 0x04, IO1H)
                        CreateWordField (RSRC, 0x09, IRQX)
                        Store (Zero, IO1L)
                        Store (Zero, IO1H)
                        Store (Zero, IRQX)
                        ENFG (0x04)
                        And (CR30, 0x01, Local0)
                        If (Local0)
                        {
                            Store (CR60, IO1L)
                            ShiftLeft (IO1L, 0x08, Local1)
                            Or (CR61, Local1, Local2)
                            Store (Local2, IO1L)
                            Store (Local2, IO1H)
                            Store (CR70, Local1)
                            ShiftLeft (One, Local1, IRQX)
                        }
                        Else
                        {
                            Store (Zero, IO1L)
                            Store (Zero, IO1H)
                            Store (Zero, IRQX)
                        }

                        EXFG ()
                        Return (RSRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                            IRQNoFlags () {4}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
                            IRQNoFlags () {3}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
                            IRQNoFlags () {4}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
                            IRQNoFlags () {3}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                            IRQNoFlags () {3}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
                            IRQNoFlags () {4}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
                            IRQNoFlags () {3}
                        }
                        StartDependentFn (0x00, 0x01)
                        {
                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
                            IRQNoFlags () {4}
                        }
                        EndDependentFn ()
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, RSRC)
                        CreateWordField (RSRC, 0x02, IO1L)
                        CreateWordField (RSRC, 0x09, IRQX)
                        ENFG (0x04)
                        And (IO1L, 0xFF, CR61)
                        ShiftRight (IO1L, 0x08, CR60)
                        FindSetRightBit (IRQX, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, CR70)
                        Store (0x01, CR30)
                        EXFG ()
                    }

                    Method (_PSC, 0, NotSerialized)
                    {
                        ENFG (0x04)
                        And (CR30, 0x01, Local0)
                        EXFG ()
                        If (Local0)
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            Return (0x03)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        ENFG (0x04)
                        Store (0x01, CR30)
                        EXFG ()
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        ENFG (0x04)
                        Store (0x00, CR30)
                        EXFG ()
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x0A, 
                        0x04
                    })
                    Name (SV60, 0x00)
                    Name (SV61, 0x00)
                    Name (IRQV, 0x00)
                    Method (SAVE, 0, NotSerialized)
                    {
                        ENFG (0x04)
                        And (CR30, 0x01, Local0)
                        If (Local0)
                        {
                            Store (CR60, SV60)
                            Store (CR61, SV61)
                            Store (CR70, IRQV)
                        }

                        EXFG ()
                    }

                    Method (REST, 0, NotSerialized)
                    {
                        If (LNot (LEqual (SV60, Zero)))
                        {
                            ENFG (0x04)
                            Or (CR30, 0x01, CR30)
                            Store (SV60, CR60)
                            Store (SV61, CR61)
                            Store (IRQV, CR70)
                            EXFG ()
                        }
                    }
                }

                Mutex (MTIO, 0x00)
                Method (ECOK, 0, NotSerialized)
                {
                    If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x01))
                    {
                        Return (0x01)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

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

                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
// Changed "AnyAcc" for "ByteAcc" according to the compilation error message        
                    Field (ERAM, ByteAcc, Lock, Preserve)
                    {
                        Offset (0x60), 
                        SMPR,   8, 
                        SMST,   8, 
                        SMAD,   8, 
                        SMCM,   8, 
                        SMD0,   256, 
                        BCNT,   8, 
                        SMAA,   8, 
                        Offset (0x90), 
                        CHGM,   16, 
                        CHGS,   16, 
                        CHGC,   16, 
                        CHGV,   16, 
                        CHGA,   16, 
                        BAL0,   1, 
                        BAL1,   1, 
                        BAL2,   1, 
                        BAL3,   1, 
                        Offset (0x9C), 
                        BEEP,   1, 
                        FAN1,   1, 
                        FAN2,   1, 
                        CRT,    1, 
                        EXFD,   1, 
                        PHDD,   1, 
                        SHDD,   1, 
                        FDD,    1, 
                        SBTN,   1, 
                        VIDO,   1, 
                        VOLD,   1, 
                        VOLU,   1, 
                        MUTE,   1, 
                        CONT,   1, 
                        BRGT,   1, 
                        HBTN,   1, 
                        S4S,    1, 
                        SKEY,   1, 
                        BKEY,   1, 
                        Offset (0xA3), 
                        S0LD,   1, 
                        S3LD,   1, 
                        VGAQ,   1, 
                        PCMQ,   1, 
                        PCMR,   1, 
                        ADP,    1, 
                        SYS6,   1, 
                        SYS7,   1, 
                        PWAK,   1, 
                        MWAK,   1, 
                        LWAK,   1, 
                        Offset (0xA5), 
                        FOT,    8, 
                        FSD1,   8, 
                        FSD2,   8, 
                        Offset (0xAF), 
                        THMM,   1, 
                        FNB0,   1, 
                        FNB1,   1, 
                        Offset (0xB0), 
                        CTMP,   8, 
                            ,   1, 
                        LIDS,   1, 
                        PMEE,   1, 
                        PWBT,   1, 
                        RINI,   1, 
                        Offset (0xB8), 
                        BCTL,   6, 
                        BLED,   1, 
                        Offset (0xB9), 
                        BRTS,   8, 
                        Offset (0xBB), 
                        WLAT,   1, 
                        BTAT,   1, 
                        WLEX,   1, 
                        BTEX,   1, 
                        KLSW,   1, 
                        Offset (0xBE), 
                        RSMT,   16, 
                            ,   4, 
                        BMF0,   3, 
                        BTY0,   1, 
                        BST0,   8, 
                        BRC0,   16, 
                        BSN0,   16, 
                        BPV0,   16, 
                        BDV0,   16, 
                        BDC0,   16, 
                        BFC0,   16, 
                        GAU0,   8, 
                        Offset (0xE0), 
                            ,   4, 
                        BMF1,   3, 
                        BTY1,   1, 
                        BST1,   8, 
                        BRC1,   16, 
                        BSN1,   16, 
                        BPV1,   16, 
                        BDV1,   16, 
                        BDC1,   16, 
                        BFC1,   16, 
                        GAU1,   8
                    }

                    OperationRegion (CCLK, SystemIO, 0x8010, 0x04)
                    Field (CCLK, DWordAcc, NoLock, Preserve)
                    {
                            ,   1, 
                        DUTY,   3, 
                        THEN,   1, 
                        Offset (0x01)
                    }

                    OperationRegion (ECRM, EmbeddedControl, 0x00, 0xFF)
// Changed "AnyAcc" for "ByteAcc" according to the compilation error message        
                    Field (ECRM, ByteAcc, Lock, Preserve)
                    {
                        Offset (0xAE), 
                        THR0,   7, 
                        THR7,   1
                    }

                    Method (PCLK, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.LPCB.EC0.THR7, 0x01))
                        {
                            Store (0x00, \_SB.PCI0.PWR.ENB1)
                            Store (0x01, \_SB.PCI0.PWR.ENB2)
                            Store (0x03, \_SB.PCI0.PWR.THPE)
                            Store (0x04, Local0)
                            Not (Local0, Local0)
                            Add (Local0, 0x01, Local0)
                            And (Local0, 0x07, Local0)
                            Store (Local0, DUTY)
                            Store (0x01, THEN)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.LPCB.EC0.THR0, 0x00))
                            {
                                Store (0x00, THEN)
                                Store (0x01, \_SB.PCI0.PWR.ENB1)
                                Store (0x00, \_SB.PCI0.PWR.ENB2)
                                Store (0x00, \_SB.PCI0.PWR.THPE)
                                Store (0x00, DUTY)
                            }
                            Else
                            {
                                Store (\_SB.PCI0.LPCB.EC0.THR0, P80H)
                                Store (0x00, \_SB.PCI0.PWR.ENB1)
                                Store (0x01, \_SB.PCI0.PWR.ENB2)
                                Store (0x03, \_SB.PCI0.PWR.THPE)
                                Store (\_SB.PCI0.LPCB.EC0.THR0, Local0)
                                Not (Local0, Local0)
                                Add (Local0, 0x01, Local0)
                                And (Local0, 0x07, Local0)
                                Store (Local0, DUTY)
                                Store (0x01, THEN)
                            }
                        }
                    }

                    Method (_Q11, 0, NotSerialized)
                    {
                        Store ("=====QUERY_11=====", Debug)
                        If (\_SB.PCI0.LPCB.EC0.BRGT)
                        {
                            Store (\_SB.PCI0.LPCB.EC0.BRTS, INF)
                            PHSS (0x08)
                            Store (0x00, \_SB.PCI0.LPCB.EC0.BRGT)
                        }
                    }

                    Method (_Q16, 0, NotSerialized)
                    {
                        Store ("=====QUERY_16=====", Debug)
                        Store (0x01, LIDS)
                        Notify (\_SB.LID, 0x80)
                    }

                    Method (_Q1C, 0, NotSerialized)
                    {
                        Store ("=====QUERY_1C=====", Debug)
                        Store ("=====Display switch=====", Debug)
                        If (\_SB.PCI0.LPCB.EC0.VIDO)
                        {
                            PHSS (0x01)
                            Store (0x00, \_SB.PCI0.LPCB.EC0.VIDO)
                        }
                    }

                    Method (_Q1D, 0, NotSerialized)
                    {
                        Store ("=====QUERY_1D=====", Debug)
                        Store (0x1D, P80H)
                        Sleep (0x07D0)
                        If (\_SB.PCI0.LPCB.EC0.ECOK)
                        {
                            Store (0x1D, P80H)
                            Sleep (0x07D0)
                            PCLK ()
                        }
                    }

                    Method (_Q1E, 0, NotSerialized)
                    {
                        Store ("=====QUERY_1E=====", Debug)
                        Store (0x1E, P80H)
                        Sleep (0x07D0)
                        If (\_SB.PCI0.LPCB.EC0.ECOK)
                        {
                            Store (0x1D, P80H)
                            Sleep (0x07D0)
                            PCLK ()
                        }
                    }

                    Method (_Q22, 0, NotSerialized)
                    {
                        Store ("=====QUERY_22=====", Debug)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
                    }

                    Method (_Q23, 0, NotSerialized)
                    {
                        Store ("=====QUERY_23=====", Debug)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
                    }

                    Method (_Q25, 0, NotSerialized)
                    {
                        Store ("=====QUERY_25=====", Debug)
                        Sleep (0x07D0)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
                        Sleep (0x64)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
                    }

                    Method (_Q37, 0, NotSerialized)
                    {
                        Store ("=====QUERY_37=====", Debug)
                        Notify (\_SB.PCI0.LPCB.ACAD, 0x80)
                        Sleep (0x64)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
                        Sleep (0x64)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
                    }

                    Method (_Q38, 0, NotSerialized)
                    {
                        Store ("=====QUERY_38=====", Debug)
                        Notify (\_SB.PCI0.LPCB.ACAD, 0x80)
                        Sleep (0x64)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
                        Sleep (0x64)
                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
                    }

                    Method (_Q41, 0, NotSerialized)
                    {
                        Store ("=====QUERY_41=====", Debug)
                    }
                }

                Device (BAT1)
                {
                    Name (_HID, EisaId ("PNP0C0A"))
                    Name (_UID, 0x01)
                    Name (_PCL, Package (0x01)
                    {
                        \_SB
                    })
                    Name (FUCC, 0x0F3C)
                    Name (PBIF, Package (0x0D)
                    {
                        0x01, 
                        0x0F3C, 
                        0x0F3C, 
                        0x01, 
                        0x39D0, 
                        0x0186, 
                        0x75, 
                        0x40, 
                        0x40, 
                        "BAT1", 
                        " ", 
                        "LiON", 
                        "FSC "
                    })
                    Name (PBST, Package (0x04)
                    {
                        0x01, 
                        0x00, 
                        0x079F, 
                        0x39D0
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LAnd (\_SB.PCI0.LPCB.EC0.ECOK, LEqual (ECDY, 0x00)))
                        {
                            Store ("==Battery _STA==", Debug)
                            Store (0x01, Local0)
                            Store (\_SB.PCI0.LPCB.EC0.BAL0, Local0)
                            If (LNot (LEqual (Local0, 0x00)))
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x0F)
                            }
                        }
                        Else
                        {
                            Return (0x1F)
                        }
                    }

                    Method (_BIF, 0, NotSerialized)
                    {
                        If (LAnd (\_SB.PCI0.LPCB.EC0.ECOK, LEqual (ECDY, 0x00)))
                        {
                            Store ("==Battery _BIF==", Debug)
                            Store (\_SB.PCI0.LPCB.EC0.BDC0, Local0)
                            Store (Local0, Index (PBIF, 0x01))
                            Store (Local0, Local2)
                            Store (Local2, Index (PBIF, 0x02))
                            Store (Local2, FUCC)
                            Store (\_SB.PCI0.LPCB.EC0.BMF0, Local1)
                            If (LEqual (Local1, 0x01))
                            {
                                Store ("Sanyo_LiON", Index (PBIF, 0x09))
                            }
                            Else
                            {
                                If (LEqual (Local1, 0x02))
                                {
                                    Store ("Sony_LiON", Index (PBIF, 0x09))
                                }
                                Else
                                {
                                    If (LEqual (Local1, 0x04))
                                    {
                                        Store ("Panasonic_LiON", Index (PBIF, 0x09))
                                    }
                                    Else
                                    {
                                        Store ("Samsung_LiON", Index (PBIF, 0x09))
                                    }
                                }
                            }
                        }

                        Return (PBIF)
                    }

                    Method (_BST, 0, NotSerialized)
                    {
                        If (\_SB.PCI0.LPCB.EC0.ADP)
                        {
                            Store (0x02, Local0)
                        }
                        Else
                        {
                            Store (0x01, Local0)
                        }

                        Store (DerefOf (Index (PBST, 0x02)), Local2)
                        If (LAnd (\_SB.PCI0.LPCB.EC0.ECOK, LEqual (ECDY, 0x00)))
                        {
                            Store ("==Battery _BST==", Debug)
                            Store (\_SB.PCI0.LPCB.EC0.GAU0, Local2)
                            Store (FUCC, Local1)
                            Store (Local2, Local4)
                            Multiply (Local2, Local1, Local2)
                            If (Local2)
                            {
                                Divide (Local2, 0x64, Local1, Local2)
                                If (LNot (LGreater (Local4, 0x63)))
                                {
                                    Increment (Local2)
                                }
                            }

                            If (\_SB.PCI0.LPCB.EC0.ADP)
                            {
                                If (LEqual (Local4, 0x64))
                                {
                                    Store (0x00, Local0)
                                }
                            }
                        }

                        Store (Local0, Index (PBST, 0x00))
                        Store (Local2, Index (PBST, 0x02))
                        If (LGreater (ECDY, 0x00))
                        {
                            Decrement (ECDY)
                            If (LEqual (ECDY, 0x00))
                            {
                                Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
                                Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
                            }
                        }

                        Return (PBST)
                    }
                }

                OperationRegion (GPIO, SystemIO, 0x8000, 0x3B)
                Field (GPIO, WordAcc, Lock, Preserve)
                {
                    AccessAs (DWordAcc, 0x00), 
                    Offset (0x18), 
                        ,   2, 
                    LPOL,   1
                }

                Device (ACAD)
                {
                    Name (_HID, "ACPI0003")
                    Name (_PCL, Package (0x01)
                    {
                        \_SB
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (_PSR, 0, NotSerialized)
                    {
                        Return (\_SB.PCI0.LPCB.EC0.ADP)
                    }
                }
            }

            Device (IDE)
            {
                Name (_ADR, 0x00040000)
                Method (_INI, 0, NotSerialized)
                {
                }

                Name (UDMT, Package (0x08)
                {
                    0x1E, 
                    0x2D, 
                    0x3C, 
                    0x5A, 
                    0x78, 
                    0x78, 
                    0x78, 
                    0x14
                })
                Name (PIOT, Package (0x05)
                {
                    0x78, 
                    0xB4, 
                    0xF0, 
                    0x017F, 
                    0x0258
                })
                Name (PIOC, Package (0x05)
                {
                    0x04, 
                    0x06, 
                    0x08, 
                    0x0D, 
                    0x10
                })
                Name (CBCT, Package (0x05)
                {
                    0x31, 
                    0x33, 
                    0x01, 
                    0x03, 
                    0x0A
                })
                Name (DACT, Package (0x05)
                {
                    0x03, 
                    0x03, 
                    0x04, 
                    0x05, 
                    0x08
                })
                Name (DRCT, Package (0x05)
                {
                    0x01, 
                    0x03, 
                    0x04, 
                    0x08, 
                    0x08
                })
                Name (PXLM, Package (0x05)
                {
                    0x02, 
                    0x01, 
                    0x00, 
                    0x00, 
                    0x00
                })
                OperationRegion (PCI, PCI_Config, 0x00, 0x60)
                Field (PCI, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x09), 
                        ,   4, 
                    SCHE,   1, 
                    PCHE,   1, 
                    Offset (0x0A), 
                    Offset (0x4B), 
                    U66E,   1, 
                    Offset (0x4C), 
                    Offset (0x53), 
                    CDFI,   1, 
                    CDUD,   1, 
                    Offset (0x54), 
                    PFTH,   8, 
                    SFTH,   8, 
                    PUDC,   8, 
                    SUDC,   8, 
                    PAST,   8, 
                    PCBT,   8, 
                    PTM0,   8, 
                    PTM1,   8, 
                    SAST,   8, 
                    SCBT,   8, 
                    STM0,   8, 
                    STM1,   8
                }

                Method (GTM, 3, NotSerialized)
                {
                    Store (Buffer (0x14) {}, Local0)
                    CreateDWordField (Local0, 0x00, PIO0)
                    CreateDWordField (Local0, 0x04, DMA0)
                    CreateDWordField (Local0, 0x08, PIO1)
                    CreateDWordField (Local0, 0x0C, DMA1)
                    CreateDWordField (Local0, 0x10, FLAG)
                    Store (Zero, PIO0)
                    Store (Zero, DMA0)
                    Store (Zero, PIO1)
                    Store (Zero, DMA1)
                    Store (Zero, FLAG)
                    If (Arg0)
                    {
                        ShiftRight (And (Arg0, 0x70), 0x04, Local1)
                        If (LEqual (Local1, Zero))
                        {
                            Store (0x08, Local1)
                        }

                        Add (And (Arg0, 0x0F, Local2), Local1, Local1)
                        Store (Match (^PIOC, MLE, Local1, MTR, 0x00, 0x00), Local2)
                        Store (DerefOf (Index (^PIOT, Local2)), PIO0)
                        If (LNot (LGreater (PIO0, 0xF0)))
                        {
                            Or (FLAG, 0x02, FLAG)
                        }
                    }

                    If (And (Arg2, 0x08))
                    {
                        Store (DerefOf (Index (^UDMT, And (Arg2, 0x07))), DMA0)
                        Or (FLAG, 0x01, FLAG)
                    }
                    Else
                    {
                        Store (PIO0, DMA0)
                    }

                    If (Arg1)
                    {
                        ShiftRight (And (Arg1, 0x70), 0x04, Local1)
                        If (LEqual (Local1, Zero))
                        {
                            Store (0x08, Local1)
                        }

                        Add (And (Arg1, 0x0F, Local2), Local1, Local1)
                        Store (Match (^PIOC, MLE, Local1, MTR, 0x00, 0x00), Local2)
                        Store (DerefOf (Index (^PIOT, Local2)), PIO1)
                        If (LNot (LGreater (PIO1, 0xF0)))
                        {
                            Or (FLAG, 0x08, FLAG)
                        }
                    }

                    If (And (Arg2, 0x80))
                    {
                        Store (DerefOf (Index (^UDMT, ShiftRight (And (Arg2, 0x70), 0x04))), DMA1)
                        Or (FLAG, 0x04, FLAG)
                    }
                    Else
                    {
                        Store (PIO1, DMA1)
                    }

                    Or (FLAG, 0x10, FLAG)
                    Return (Local0)
                }

                Method (STM, 3, NotSerialized)
                {
                    Store (Buffer (0x06)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        }, Local7)
                    CreateByteField (Local7, 0x00, TM0)
                    CreateByteField (Local7, 0x01, TM1)
                    CreateByteField (Local7, 0x02, UDC)
                    CreateByteField (Local7, 0x03, AST)
                    CreateByteField (Local7, 0x04, CBT)
                    CreateByteField (Local7, 0x05, U66)
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Store (FLAG, Local6)
                    Store (Ones, Local4)
                    If (LOr (DMA0, PIO0))
                    {
                        If (LAnd (DMA0, LNot (PIO0)))
                        {
                            If (And (Local6, 0x01))
                            {
                                If (LAnd (LLess (DMA0, 0x1E), LNot (LLess (DMA0, 0x0F))))
                                {
                                    Store (0x07, Local0)
                                }
                                Else
                                {
                                    Store (Match (^UDMT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                }

                                Or (Local0, 0x08, UDC)
                                If (LLess (DMA0, 0x3C))
                                {
                                    Store (One, U66)
                                }
                            }

                            Store (Match (^PIOT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
                            Store (Local0, Local4)
                        }

                        If (LAnd (LNot (DMA0), PIO0))
                        {
                            Store (Match (^PIOT, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
                            Store (Local0, Local4)
                        }

                        If (LAnd (DMA0, PIO0))
                        {
                            If (And (Local6, 0x01))
                            {
                                If (LAnd (LLess (DMA0, 0x1E), LNot (LLess (DMA0, 0x0F))))
                                {
                                    Store (0x07, Local0)
                                }
                                Else
                                {
                                    Store (Match (^UDMT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                }

                                Or (Local0, 0x08, UDC)
                                If (LLess (DMA0, 0x3C))
                                {
                                    Store (One, U66)
                                }
                            }

                            If (LNot (LLess (PIO0, DMA0)))
                            {
                                Store (Match (^PIOT, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                                Store (Local0, Local4)
                            }
                            Else
                            {
                                Store (Match (^PIOT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                Store (Local0, Local4)
                            }

                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
                        }
                    }

                    Store (Ones, Local5)
                    If (LOr (DMA1, PIO1))
                    {
                        If (LAnd (DMA1, LNot (PIO1)))
                        {
                            If (And (Local6, 0x04))
                            {
                                If (LAnd (LLess (DMA1, 0x1E), LNot (LLess (DMA1, 0x0F))))
                                {
                                    Store (0x07, Local0)
                                }
                                Else
                                {
                                    Store (Match (^UDMT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
                                }

                                Or (ShiftLeft (Or (Local0, 0x08), 0x04), UDC, UDC)
                                If (LLess (DMA1, 0x3C))
                                {
                                    Store (One, U66)
                                }
                            }

                            Store (Match (^PIOT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM1)
                            Store (Local0, Local5)
                        }

                        If (LAnd (LNot (DMA1), PIO1))
                        {
                            Store (Match (^PIOT, MGE, PIO1, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM1)
                            Store (Local0, Local5)
                        }

                        If (LAnd (DMA1, PIO1))
                        {
                            If (And (Local6, 0x04))
                            {
                                If (LAnd (LLess (DMA1, 0x1E), LNot (LLess (DMA1, 0x0F))))
                                {
                                    Store (0x07, Local0)
                                }
                                Else
                                {
                                    Store (Match (^UDMT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
                                }

                                Or (ShiftLeft (Or (Local0, 0x08), 0x04), UDC, UDC)
                                If (LLess (DMA1, 0x3C))
                                {
                                    Store (One, U66)
                                }
                            }

                            If (LNot (LLess (PIO1, DMA1)))
                            {
                                Store (Match (^PIOT, MGE, PIO1, MTR, 0x00, 0x00), Local0)
                                Store (Local0, Local5)
                            }
                            Else
                            {
                                Store (Match (^PIOT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
                                Store (Local0, Local5)
                            }

                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM1)
                        }
                    }

                    If (LEqual (Local4, Ones))
                    {
                        If (LEqual (Local5, Ones))
                        {
                            Store (Zero, CBT)
                        }
                        Else
                        {
                            Store (DerefOf (Index (^CBCT, Local5)), CBT)
                        }
                    }
                    Else
                    {
                        If (LEqual (Local5, Ones))
                        {
                            Store (DerefOf (Index (^CBCT, Local4)), CBT)
                        }
                        Else
                        {
                            If (LNot (LLess (Local4, Local5)))
                            {
                                Store (DerefOf (Index (^CBCT, Local4)), CBT)
                            }
                            Else
                            {
                                Store (DerefOf (Index (^CBCT, Local5)), CBT)
                            }
                        }
                    }

                    Store (0x02, AST)
                    Return (Local7)
                }

                Method (GTF0, 3, NotSerialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local7)
                    CreateByteField (Local7, 0x01, MODE)
                    If (And (Arg1, 0x08))
                    {
                        And (Arg1, 0x07, Local0)
                        If (LEqual (Local0, 0x07))
                        {
                            Store (0x05, MODE)
                        }
                        Else
                        {
                            Subtract (0x04, Local0, MODE)
                        }

                        Or (MODE, 0x40, MODE)
                    }
                    Else
                    {
                        And (Arg2, 0x0F, Local0)
                        Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                        Store (DerefOf (Index (^PXLM, Local1)), MODE)
                        Or (MODE, 0x20, MODE)
                    }

                    Concatenate (Local7, Local7, Local6)
                    And (Arg2, 0x0F, Local0)
                    Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                    Subtract (0x04, Local1, MODE)
                    Or (MODE, 0x08, MODE)
                    Concatenate (Local6, Local7, Local5)
                    Return (Local5)
                }

                Method (GTF1, 3, NotSerialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                        }, Local7)
                    CreateByteField (Local7, 0x01, MODE)
                    If (And (Arg1, 0x80))
                    {
                        ShiftRight (And (Arg1, 0x70), 0x04, Local0)
                        If (LEqual (Local0, 0x07))
                        {
                            Store (0x05, MODE)
                        }
                        Else
                        {
                            Subtract (0x04, Local0, MODE)
                        }

                        Or (MODE, 0x40, MODE)
                    }
                    Else
                    {
                        And (Arg2, 0x0F, Local0)
                        Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                        Store (DerefOf (Index (^PXLM, Local1)), MODE)
                        Or (MODE, 0x20, MODE)
                    }

                    Concatenate (Local7, Local7, Local6)
                    And (Arg2, 0x0F, Local0)
                    Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                    Subtract (0x04, Local1, MODE)
                    Or (MODE, 0x08, MODE)
                    Concatenate (Local6, Local7, Local5)
                    Return (Local5)
                }

                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Name (_PSC, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

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

                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Primary Controller", Debug)
                        Store (^^GTM (^^PTM0, ^^PTM1, ^^PUDC), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Primary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateByteField (Local0, 0x00, TM0)
                        CreateByteField (Local0, 0x01, TM1)
                        CreateByteField (Local0, 0x02, UDC)
                        CreateByteField (Local0, 0x03, AST)
                        CreateByteField (Local0, 0x04, CBT)
                        CreateByteField (Local0, 0x05, U66)
                        Store (TM0, ^^PTM0)
                        Store (TM1, ^^PTM1)
                        Store (UDC, ^^PUDC)
                        Store (AST, ^^PAST)
                        Store (CBT, ^^PCBT)
                        If (U66)
                        {
                            Store (U66, ^^U66E)
                        }

                        Store (0x55, ^^PFTH)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Primary Master", Debug)
                            Store (^^^GTF0 (^^^PCHE, ^^^PUDC, ^^^PTM0), Local0)
                            Return (Local0)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Primary Slave", Debug)
                            Store (^^^GTF1 (^^^PCHE, ^^^PUDC, ^^^PTM1), Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SECN)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Secondary Controller", Debug)
                        Store (^^GTM (^^STM0, ^^STM1, ^^SUDC), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Secondary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateByteField (Local0, 0x00, TM0)
                        CreateByteField (Local0, 0x01, TM1)
                        CreateByteField (Local0, 0x02, UDC)
                        CreateByteField (Local0, 0x03, AST)
                        CreateByteField (Local0, 0x04, CBT)
                        CreateByteField (Local0, 0x05, U66)
                        Store (TM0, ^^STM0)
                        Store (TM1, ^^STM1)
                        Store (UDC, ^^SUDC)
                        Store (AST, ^^SAST)
                        Store (CBT, ^^SCBT)
                        If (U66)
                        {
                            Store (U66, ^^U66E)
                        }

                        Store (0x55, ^^SFTH)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Secondary Master", Debug)
                            Store (^^^GTF0 (^^^SCHE, ^^^SUDC, ^^^STM0), Local0)
                            Return (Local0)
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Secondary Slave", Debug)
                            Store (^^^GTF1 (^^^SCHE, ^^^SUDC, ^^^STM1), Local0)
                            Return (Local0)
                        }
                    }
                }
            }

            Device (AGP)
            {
                Name (_ADR, 0x00010000)
                Name (_PSC, 0x00)
                Name (_PRT, Package (0x01)
                {
                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKC, 
                        0x00
                    }
                })
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, _PSC)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x02, _PSC)
                }

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

            Device (USB0)
            {
                Name (_ADR, 0x00020000)
            }

            Device (USB1)
            {
                Name (_ADR, 0x000F0000)
            }

            Device (AUDO)
            {
                Name (_ADR, 0x00080000)
            }

            Device (MODM)
            {
                Name (_ADR, 0x00030000)
                Name (_PSC, 0x00)
                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x04
                })
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, _PSC)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x02, _PSC)
                }

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

            Device (ENET)
            {
                Name (_ADR, 0x00090000)
                Name (_PSC, 0x00)
                Name (_PRW, Package (0x02)
                {
                    0x0A, 
                    0x04
                })
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, _PSC)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x02, _PSC)
                }

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

            Device (V194)
            {
                Name (_ADR, 0x000A0000)
            }

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

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x02, _PSC)
                }

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

            Device (CDB1)
            {
                Name (_ADR, 0x000B0001)
                Name (_PSC, 0x00)
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, _PSC)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (0x02, _PSC)
                }

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

            Device (SLT1)
            {
                Name (_ADR, 0x00100000)
            }

            Device (SLT2)
            {
                Name (_ADR, 0x00140000)
            }
        }
    }

    Scope (_GPE)
    {
        Method (_L09, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.MODM, 0x02)
        }

        Method (_L0A, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.ENET, 0x02)
        }

        Method (_L02, 0, NotSerialized)
        {
            Store ("======LID=====", Debug)
            Notify (\_SB.LID, 0x80)
        }
    }

    Scope (_TZ)
    {
        Name (TBSE, 0x0AAC)
        Name (DTMP, 0x0CA0)
        Name (DCRT, 0x12AE)
        Name (DAC0, 0x0D68)
        Name (DPSV, 0x127C)
        ThermalZone (THRM)
        {
            Method (_TMP, 0, NotSerialized)
            {
                If (\_SB.PCI0.LPCB.EC0.ECOK)
                {
                    If (\_SB.PCI0.LPCB.EC0.CTMP)
                    {
                        Return (Add (Multiply (\_SB.PCI0.LPCB.EC0.CTMP, 0x0A), TBSE))
                    }
                    Else
                    {
                        Return (DTMP)
                    }
                }
                Else
                {
                    Return (DTMP)
                }
            }

            Method (_AC0, 0, NotSerialized)
            {
                Return (DAC0)
            }

            Method (_PSV, 0, NotSerialized)
            {
                Return (DPSV)
            }

            Method (_CRT, 0, NotSerialized)
            {
                Return (DCRT)
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU0
            })
            Name (_TC1, 0x02)
            Name (_TC2, 0x05)
            Name (_TSP, 0x96)
        }
    }

    Scope (\_PR.CPU0)
    {
        Name (_PCT, Package (0x02)
        {
            ResourceTemplate ()
            {
                Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
            },

            ResourceTemplate ()
            {
                Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
            }
        })
        Name (_PSS, Package (0x19)
        {

// 1800mhz 13.5x 133mhz 1.300v
            Package (0x06)
            {
                0x00000708,
                0x000076D4,
                0x0000007D,
                0x0000007D,
                0x00D059D5,
                0x000001D5
            },

// 1730mhz 13x 133mhz 1.250v
            Package (0x06)
            {
		0x000006C2,
		0x00006996,
		0x0000007D,
		0x0000007D,
		0x00D05A34,
		0x00000234
            },

// 1663mhz 12.5x 133mhz 1.200v
            Package (0x06)
            {
		0x0000067F,
		0x00005D86,
		0x0000007D,
		0x0000007D,
		0x00005A63,
		0x00000263
            },

// 1596mhz 12x 133mhz 1.200v
            Package (0x06)
            {
		0x0000063C,
		0x0000599B,
		0x0000007D,
		0x0000007D,
		0x00005A62,
		0x00000262
            },

// 1530mhz 11.5x 133mhz 1.200v
            Package (0x06)
            {
		0x000005FA,
		0x00005610,
		0x0000007D,
		0x0000007D,
		0x00D05A61,
		0x00000261
            },

// 1463mhz 11x 133mhz 1.150v
            Package (0x06)
            {
                0x000005B7,
                0x00004B94,
                0x0000007D,
                0x0000007D,
                0x00D05AA0,
                0x000002A0
            },

// 1396mhz 10.5x 133mhz 1.150v
            Package (0x06)
            {
                0x00000574,
                0x0000481E,
                0x0000007D,
                0x0000007D,
                0x00D05AAF,
                0x000002AF
            },

// 1330mhz 10x 133mhz 1.150v
            Package (0x06)
            {
                0x00000532,
                0x000044B5,
                0x0000007D,
                0x0000007D,
                0x00D05AAE,
                0x000002AE
            },

// 1266mhz 9.5x 133mhz 1.100v
            Package (0x06)
            {
                0x000004F2,
                0x00003BD6,
                0x0000007D,
                0x0000007D,
                0x00D05AED,
                0x000002ED
            },

// 1199mhz 9x 133mhz 1.050v
            Package (0x06)
            {
                0x000004AF,
                0x00003030,
                0x0000007D,
                0x0000007D,
                0x00D05B2C,
                0x0000032C
            },

// 1133mhz 8.5x 133mhz 0.975v
            Package (0x06)
            {
                0x0000046D,
                0x00002A12,
                0x0000007D,
                0x0000007D,
                0x00D05B8B,
                0x0000038B
            },

// 1066mhz 8x 133mhz 0.925v
            Package (0x06)
            {
                0x0000042A,
                0x000023A0,
                0x0000007D,
                0x0000007D,
                0x00D05BCA,
                0x000003CA
            },

// 999mhz 7.5x 133mhz 0.925v
            Package (0x06)
            {
                0x000003E7,
                0x00002163,
                0x0000007D,
                0x0000007D,
                0x00D05BC9,
                0x000003C9
            },

// 933mhz 7x 133mhz 0.925v
            Package (0x06)
            {
                0x000003A5,
                0x00001F2E,
                0x0000007D,
                0x0000007D,
                0x00D05BC8,
                0x000003C8
            },

// 866mhz 6.5x 133mhz 0.925v
            Package (0x06)
            {
                0x00000362,
                0x00001CF1,
                0x0000007D,
                0x0000007D,
                0x00D05BC7,
                0x000003C7
            },

// 800mhz 6x 133mhz 0.925v
            Package (0x06)
            {
                0x00000320,
                0x00001ABD,
                0x0000007D,
                0x0000007D,
                0x00D05BC6,
                0x000003C6
            },

// 733mhz 5.5x 133mhz 0.925v
            Package (0x06)
            {
                0x000002DD,
                0x0000187F,
                0x0000007D,
                0x0000007D,
                0x00D05BC5,
                0x000003C5
            },

// 666mhz 5x 133mhz 0.925v
            Package (0x06)
            {
                0x0000029A,
                0x00001642,
                0x0000007D,
                0x0000007D,
                0x00D05BC4,
                0x000003C4
            },

// 533mhz 4x 133mhz 0.925v
            Package (0x06)
            {
                0x00000215,
                0x000011D0,
                0x0000007D,
                0x0000007D,
                0x00D05BD2,
                0x000003D2
            }

        })
    }
}

-------------- next part --------------
	map[10]: type 1, range 32, base f4400000, size 12, enabled
pcib0: matched entry for 0.2.INTA (src \\_SB_.PCI0.LPCB.LNKU)
pcib0: possible interrupts:  9
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKC (references 1, priority 5020):
	interrupts:	     3
	penalty:	  5020
\\_SB_.PCI0.LPCB.LNKA (references 1, priority 5020):
	interrupts:	     3
	penalty:	  5020
\\_SB_.PCI0.LPCB.LNKB (references 3, priority 150):
	interrupts:	    11
	penalty:	    50
\\_SB_.PCI0.LPCB.LNKH (references 1, priority 80):
	interrupts:	     5
	penalty:	    80
\\_SB_.PCI0.LPCB.LNKU (references 1, priority 60):
	interrupts:	     9
	penalty:	    60
\\_SB_.PCI0.LPCB.LNKG (references 1, priority 55):
	interrupts:	    10    11     9     5
	penalty:	    30    50    60    80
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 55):
	interrupts:	    10    11     9     5
	penalty:	    30    50    60    80
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 30):
	interrupts:	    10
	penalty:	    30
pcib0: slot 2 INTA routed to irq 9 via \\_SB_.PCI0.LPCB.LNKU
found->	vendor=0x10b9, dev=0x5237, revid=0x03
	bus=0, slot=2, func=0
	class=0c-03-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0017, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x50 (20000 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D3  current D0
	map[10]: type 1, range 32, base f4401000, size 12, enabled
	map[14]: type 4, range 32, base 00008400, size  8, enabled
pcib0: matched entry for 0.3.INTA (src \\_SB_.PCI0.LPCB.LNKG)
pcib0: possible interrupts:  5  9 10 11
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKC (references 1, priority 5040):
	interrupts:	     3
	penalty:	  5040
\\_SB_.PCI0.LPCB.LNKA (references 1, priority 5040):
	interrupts:	     3
	penalty:	  5040
\\_SB_.PCI0.LPCB.LNKB (references 3, priority 300):
	interrupts:	    11
	penalty:	   100
\\_SB_.PCI0.LPCB.LNKH (references 1, priority 110):
	interrupts:	     5
	penalty:	   110
\\_SB_.PCI0.LPCB.LNKG (references 1, priority 100):
	interrupts:	    10    11     5     9
	penalty:	    60   100   110   130
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 100):
	interrupts:	    10    11     5     9
	penalty:	    60   100   110   130
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 60):
	interrupts:	    10
	penalty:	    60
pcib0: slot 3 INTA routed to irq 11 via \\_SB_.PCI0.LPCB.LNKG
found->	vendor=0x10b9, dev=0x5457, revid=0x00
	bus=0, slot=3, func=0
	class=07-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0003, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=11
	powerspec 2  supports D0 D3  current D0
	map[20]: type 4, range 32, base 0000a000, size  4, enabled
found->	vendor=0x10b9, dev=0x5229, revid=0xc4
	bus=0, slot=4, func=0
	class=01-01-fa, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x04 (1000 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D3  current D0
found->	vendor=0x10b9, dev=0x7101, revid=0x00
	bus=0, slot=6, func=0
	class=06-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0200, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
found->	vendor=0x10b9, dev=0x1533, revid=0x00
	bus=0, slot=7, func=0
	class=06-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x000f, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	powerspec 1  supports D0 D3  current D0
	map[10]: type 4, range 32, base 00008800, size  8, enabled
	map[14]: type 1, range 32, base f4402000, size 12, enabled
pcib0: matched entry for 0.8.INTA (src \\_SB_.PCI0.LPCB.LNKH)
pcib0: possible interrupts:  5
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKC (references 1, priority 5060):
	interrupts:	     3
	penalty:	  5060
\\_SB_.PCI0.LPCB.LNKA (references 1, priority 5060):
	interrupts:	     3
	penalty:	  5060
\\_SB_.PCI0.LPCB.LNKB (references 3, priority 480):
	interrupts:	    11
	penalty:	   160
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 145):
	interrupts:	    10     5    11     9
	penalty:	    90   140   160   190
\\_SB_.PCI0.LPCB.LNKH (references 1, priority 140):
	interrupts:	     5
	penalty:	   140
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 90):
	interrupts:	    10
	penalty:	    90
pcib0: slot 8 INTA routed to irq 5 via \\_SB_.PCI0.LPCB.LNKH
found->	vendor=0x10b9, dev=0x5451, revid=0x02
	bus=0, slot=8, func=0
	class=04-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0003, statreg=0xc290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x18 (6000 ns)
	intpin=a, irq=5
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 4, range 32, base 00008c00, size  8, enabled
	map[14]: type 1, range 32, base f4406800, size  8, enabled
pcib0: matched entry for 0.9.INTA (src \\_SB_.PCI0.LPCB.LNKB)
pcib0: possible interrupts: 11
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKC (references 1, priority 5080):
	interrupts:	     3
	penalty:	  5080
\\_SB_.PCI0.LPCB.LNKA (references 1, priority 5080):
	interrupts:	     3
	penalty:	  5080
\\_SB_.PCI0.LPCB.LNKB (references 3, priority 630):
	interrupts:	    11
	penalty:	   210
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 190):
	interrupts:	    10     5    11     9
	penalty:	   120   180   210   250
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 120):
	interrupts:	    10
	penalty:	   120
pcib0: slot 9 INTA routed to irq 11 via \\_SB_.PCI0.LPCB.LNKB
found->	vendor=0x10ec, dev=0x8139, revid=0x10
	bus=0, slot=9, func=0
	class=02-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0003, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x20 (8000 ns), maxlat=0x40 (16000 ns)
	intpin=a, irq=11
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base f4406000, size 11, enabled
	map[14]: type 4, range 32, base 00008080, size  7, enabled
pcib0: matched entry for 0.10.INTA (src \\_SB_.PCI0.LPCB.LNKC)
pcib0: possible interrupts:  3
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKC (references 1, priority 5100):
	interrupts:	     3
	penalty:	  5100
\\_SB_.PCI0.LPCB.LNKA (references 1, priority 5100):
	interrupts:	     3
	penalty:	  5100
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 240):
	interrupts:	    10     5    11     9
	penalty:	   150   210   290   310
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 150):
	interrupts:	    10
	penalty:	   150
atpic: Programming IRQ3 as level/low
pcib0: slot 10 INTA routed to irq 3 via \\_SB_.PCI0.LPCB.LNKC
found->	vendor=0x1106, dev=0x3044, revid=0x46
	bus=0, slot=10, func=0
	class=0c-00-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0013, statreg=0x0210, cachelnsz=16 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x20 (8000 ns)
	intpin=a, irq=3
	powerspec 2  supports D0 D2 D3  current D0
	map[10]: type 1, range 32, base 00000000, size 12, enabled
pcib0: matched entry for 0.11.INTA (src \\_SB_.PCI0.LPCB.LNKA)
pcib0: possible interrupts:  3
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKA (references 1, priority 5130):
	interrupts:	     3
	penalty:	  5130
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 282):
	interrupts:	    10     5    11     9
	penalty:	   180   240   340   370
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 180):
	interrupts:	    10
	penalty:	   180
pcib0: slot 11 INTA routed to irq 3 via \\_SB_.PCI0.LPCB.LNKA
found->	vendor=0x1524, dev=0x1420, revid=0x01
	bus=0, slot=11, func=0
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0007, statreg=0x0210, cachelnsz=16 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0xc0 (48000 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=3
	powerspec 1  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base 00000000, size 12, enabled
pcib0: matched entry for 0.11.INTB (src \\_SB_.PCI0.LPCB.LNKB)
pcib0: slot 11 INTB is already routed to irq 11
found->	vendor=0x1524, dev=0x1420, revid=0x01
	bus=0, slot=11, func=1
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0007, statreg=0x0210, cachelnsz=16 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x40 (16000 ns), maxlat=0x03 (750 ns)
	intpin=b, irq=11
	powerspec 1  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base f4405000, size 12, enabled
pcib0: matched entry for 0.15.INTA (src \\_SB_.PCI0.LPCB.LNKE)
pcib0: possible interrupts:  5  9 10 11
ACPI PCI link arbitrated settings:
\\_SB_.PCI0.LPCB.LNKE (references 1, priority 325):
	interrupts:	    10     5    11     9
	penalty:	   210   270   390   430
\\_SB_.PCI0.LPCB.LNKD (references 1, priority 210):
	interrupts:	    10
	penalty:	   210
pcib0: slot 15 INTA routed to irq 10 via \\_SB_.PCI0.LPCB.LNKE
found->	vendor=0x10b9, dev=0x5237, revid=0x03
	bus=0, slot=15, func=0
	class=0c-03-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0017, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x50 (20000 ns)
	intpin=a, irq=10
	powerspec 2  supports D0 D3  current D0
pcib1: <ACPI PCI-PCI bridge> at device 1.0 on pci0
pcib1:   secondary bus     1
pcib1:   subordinate bus   1
pcib1:   I/O decode        0xb000-0xbfff
pcib1:   memory decode     0xf4500000-0xf45fffff
pcib1:   prefetched decode 0xf6000000-0xf7ffffff
ACPI PCI link initial configuration:
\\_SB_.PCI0.LPCB.LNKC irq* 3: [ 3]  0+ low,level,sharable 1.5.0
pci1: <ACPI PCI bus> on pcib1
pci1: physical bus=1
	map[10]: type 3, range 32, base f6000000, size 25, enabled
pcib1: device (null) requested decoded memory range 0xf6000000-0xf7ffffff
	map[14]: type 4, range 32, base 0000b000, size  8, enabled
pcib1: device (null) requested decoded I/O range 0xb000-0xb0ff
	map[18]: type 1, range 32, base f4500000, size 16, enabled
pcib1: device (null) requested decoded memory range 0xf4500000-0xf450ffff
pcib1: matched entry for 1.5.INTA (src \\_SB_.PCI0.LPCB.LNKC)
pcib1: slot 5 INTA is already routed to irq 3
found->	vendor=0x1002, dev=0x4336, revid=0x00
	bus=1, slot=5, func=0
	class=03-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0287, statreg=0x02b0, cachelnsz=16 (dwords)
	lattimer=0x42 (1980 ns), mingnt=0x08 (2000 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=3
	powerspec 2  supports D0 D1 D2 D3  current D0
drm0: <ATI Radeon RS100 Mobility U1> port 0xb000-0xb0ff mem 0xf4500000-0xf450ffff,0xf6000000-0xf7ffffff irq 3 at device 5.0 on pci1
info: [drm] Initialized radeon 1.11.0 20020828 on minor 0
ohci0: <AcerLabs M5237 (Aladdin-V) USB controller> mem 0xf4400000-0xf4400fff irq 9 at device 2.0 on pci0
ohci0: Reserved 0x1000 bytes for rid 0x10 type 3 at 0xf4400000
ohci0: [GIANT-LOCKED]
usb0: OHCI version 1.0, legacy support
usb0: SMM does not respond, resetting
usb0: <AcerLabs M5237 (Aladdin-V) USB controller> on ohci0
usb0: USB revision 1.0
uhub0: AcerLabs OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 2 ports with 2 removable, self powered
pci0: <simple comms, generic modem> at device 3.0 (no driver attached)
atapci0: <AcerLabs Aladdin UDMA100 controller> port 0xa000-0xa00f,0x376,0x170-0x177,0x3f6,0x1f0-0x1f7 at device 4.0 on pci0
atapci0: Reserved 0x10 bytes for rid 0x20 type 4 at 0xa000
ata0: channel #0 on atapci0
atapci0: Reserved 0x8 bytes for rid 0x10 type 4 at 0x1f0
atapci0: Reserved 0x1 bytes for rid 0x14 type 4 at 0x3f6
ata0: reset tp1 mask=03 ostat0=50 ostat1=00
ata0-master: stat=0x50 err=0x01 lsb=0x00 msb=0x00
ata0-slave:  stat=0x00 err=0x01 lsb=0x00 msb=0x00
ata0: reset tp2 stat0=50 stat1=00 devices=0x1<ATA_MASTER>
ata0: [MPSAFE]
ata1: channel #1 on atapci0
atapci0: Reserved 0x8 bytes for rid 0x18 type 4 at 0x170
atapci0: Reserved 0x1 bytes for rid 0x1c type 4 at 0x376
ata1: reset tp1 mask=03 ostat0=50 ostat1=00
ata1-master: stat=0x00 err=0x01 lsb=0x14 msb=0xeb
ata1-slave:  stat=0x00 err=0x00 lsb=0x00 msb=0x00
ata1: reset tp2 stat0=00 stat1=00 devices=0x4<ATAPI_MASTER>
ata1: [MPSAFE]
pci0: <bridge> at device 6.0 (no driver attached)
isab0: <PCI-ISA bridge> at device 7.0 on pci0
isa0: <ISA bus> on isab0
pcm0: <Acer Labs M5451> port 0x8800-0x88ff mem 0xf4402000-0xf4402fff irq 5 at device 8.0 on pci0
pcm0: Reserved 0x100 bytes for rid 0x10 type 4 at 0x8800
pcm0: <Avance Logic ALC202 AC97 Codec (id = 0x414c4740)>
pcm0: Codec features headphone, 20 bit DAC, 18 bit ADC, 6 bit master volume, Realtek 3D Stereo Enhancement
pcm0: Primary codec extended features variable rate PCM, double rate PCM, reserved 1, AMAP, reserved 4
pcm0: [GIANT-LOCKED]
pcm0: sndbuf_setmap 1eb83000, 1000; 0xc1a4f000 -> 1eb83000
pcm0: sndbuf_setmap 239000, 1000; 0xc1a65000 -> 239000
pcm0: sndbuf_setmap 237000, 1000; 0xc1a63000 -> 237000
pcm0: sndbuf_setmap 215000, 1000; 0xc1a61000 -> 215000
pcm0: sndbuf_setmap 1eb33000, 1000; 0xc1a5f000 -> 1eb33000
rl0: Reserved 0x100 bytes for rid 0x10 type 4 at 0x8c00
rl0: <RealTek 8139 10/100BaseTX> port 0x8c00-0x8cff mem 0xf4406800-0xf44068ff irq 11 at device 9.0 on pci0
miibus0: <MII bus> on rl0
rlphy0: <RealTek internal media interface> on miibus0
rlphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
rl0: bpf attached
rl0: Ethernet address: 00:02:3f:b5:f5:88
rl0: [MPSAFE]
fwohci0: <VIA Fire II (VT6306)> port 0x8080-0x80ff mem 0xf4406000-0xf44067ff irq 3 at device 10.0 on pci0
fwohci0: Reserved 0x800 bytes for rid 0x10 type 3 at 0xf4406000
fwohci0: [MPSAFE]
fwohci0: OHCI version 1.0 (ROM=1)
fwohci0: No. of Isochronous channels is 8.
fwohci0: EUI64 00:02:3f:33:27:00:05:22
fwohci0: Phy 1394a available S400, 3 ports.
fwohci0: Link S400, max_rec 2048 bytes.
firewire0: <IEEE1394(FireWire) bus> on fwohci0
fwe0: <Ethernet over FireWire> on firewire0
if_fwe0: Fake Ethernet address: 02:02:3f:00:05:22
fwe0: bpf attached
fwe0: Ethernet address: 02:02:3f:00:05:22
fwe0: if_start running deferred for Giant
sbp0: <SBP-2/SCSI over FireWire> on firewire0
fwohci0: Initiate bus reset
fwohci0: node_id=0xc800ffc0, gen=1, CYCLEMASTER mode
firewire0: 1 nodes, maxhop <= 0, cable IRM = 0 (me)
firewire0: bus manager 0 (me)
cbb0: <ENE CB1420 PCI-CardBus Bridge> irq 3 at device 11.0 on pci0
cbb0: Lazy allocation of 0x1000 bytes rid 0x10 type 3 at 0x80000000
cardbus0: <CardBus bus> on cbb0
pccard0: <16-bit PCCard bus> on cbb0
cbb0: [MPSAFE]
cbb0: PCI Configuration space:
  0x00: 0x14201524 0x02100007 0x06070001 0x00824010 
  0x10: 0x80000000 0x020000a0 0x20020200 0xfffff000 
  0x20: 0x00000000 0xfffff000 0x00000000 0xfffffffc 
  0x30: 0x00000000 0xfffffffc 0x00000000 0x04400103 
  0x40: 0x100a1734 0x00000001 0x00000000 0x00000000 
  0x50: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x60: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x70: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x80: 0x0844d021 0x00000000 0x00000000 0x011c1122 
  0x90: 0x604406c0 0x00000000 0x00000000 0x00000000 
  0xa0: 0xfe110001 0x00c00000 0x0000000b 0x0000000b 
  0xb0: 0x0000000b 0x00000000 0x00000000 0x00000000 
  0xc0: 0x00801033 0x00800080 0x10080c11 0x00000000 
  0xd0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xe0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xf0: 0x00000000 0x00000000 0x00000000 0x00000000 
cbb1: <ENE CB1420 PCI-CardBus Bridge> irq 11 at device 11.1 on pci0
cbb1: Lazy allocation of 0x1000 bytes rid 0x10 type 3 at 0x80001000
cardbus1: <CardBus bus> on cbb1
pccard1: <16-bit PCCard bus> on cbb1
cbb1: [MPSAFE]
cbb1: PCI Configuration space:
  0x00: 0x14201524 0x02100007 0x06070001 0x00824010 
  0x10: 0x80001000 0x020000a0 0x20030300 0xfffff000 
  0x20: 0x00000000 0xfffff000 0x00000000 0xfffffffc 
  0x30: 0x00000000 0xfffffffc 0x00000000 0x0740020b 
  0x40: 0x100a1734 0x00000001 0x00000000 0x00000000 
  0x50: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x60: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x70: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x80: 0x0844d021 0x00000000 0x00000000 0x011c1122 
  0x90: 0x604406c0 0x00000000 0x00000000 0x00000000 
  0xa0: 0xfe110001 0x00c00000 0x0000000b 0x0000000b 
  0xb0: 0x0000000b 0x00000000 0x00000000 0x00000000 
  0xc0: 0x00801033 0x00800080 0x10080c11 0x00000000 
  0xd0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xe0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xf0: 0x00000000 0x00000000 0x00000000 0x00000000 
ohci1: <AcerLabs M5237 (Aladdin-V) USB controller> mem 0xf4405000-0xf4405fff irq 10 at device 15.0 on pci0
ohci1: Reserved 0x1000 bytes for rid 0x10 type 3 at 0xf4405000
ohci1: [GIANT-LOCKED]
usb1: OHCI version 1.0, legacy support
usb1: SMM does not respond, resetting
usb1: <AcerLabs M5237 (Aladdin-V) USB controller> on ohci1
usb1: USB revision 1.0
uhub1: AcerLabs OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub1: 2 ports with 2 removable, self powered
acpi_tz0: <Thermal Zone> on acpi0
acpi_tz0: _CRT value is absurd, ignored (205.0C)
acpi_tz0: _PSV value is absurd, ignored (200.0C)
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> irq 1 on atkbdc0
atkbd: the current kbd controller command byte 0067
atkbd: keyboard ID 0x41ab (2)
kbd0 at atkbd0
kbd0: atkbd0, AT 101/102 (2), config:0x0, flags:0x3d0000
atkbd0: [GIANT-LOCKED]
psm0: unable to allocate IRQ
psmcpnp0: <PS/2 mouse port> irq 12 on acpi0
psm0: current command byte:0067
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: [GIANT-LOCKED]
psm0: model GlidePoint, device ID 0-00, 2 buttons
psm0: config:00000000, flags:00000008, packet size:3
psm0: syncmask:c0, syncbits:00
fdc0: <floppy drive controller> port 0x3f7,0x3f0-0x3f5 irq 6 drq 2 on acpi0
fdc0: ic_type 90 part_id 80
fdc0: [MPSAFE]
fdc0: [FAST]
fd0: <1440-KB 3.5" drive> on fdc0 drive 0
ppc0: using extended I/O port range
ppc0: ECP SPP ECP+EPP SPP
ppc0: <ECP parallel printer port> port 0x778-0x77f,0x378-0x37f irq 7 drq 0 on acpi0
ppc0: SMC-like chipset (ECP/EPP/PS2/NIBBLE) in COMPATIBLE mode
ppc0: FIFO with 16/16/1 bytes threshold
ppbus0: <Parallel port bus> on ppc0
plip0: <PLIP network interface> on ppbus0
plip0: bpf attached
lpt0: <Printer> on ppbus0
lpt0: Interrupt-driven port
ppi0: <Parallel I/O> on ppbus0
sio0: irq maps: 0x9 0x19 0x9 0x9
sio0: <16550A-compatible COM port> port 0x3f8-0x3ff irq 4 flags 0x10 on acpi0
sio0: type 16550A
acpi_ec0: info: new max delay is 390 us
acpi_ec0: info: new max delay is 500 us
acpi_cmbat0: <Control Method Battery> on acpi0
acpi_acad0: <AC Adapter> on acpi0
npx0: [FAST]
npx0: <math processor> on motherboard
npx0: INT 16 interface
ata: ata0 already exists; skipping it
ata: ata1 already exists; skipping it
atkbdc: atkbdc0 already exists; skipping it
fdc: fdc0 already exists; skipping it
ppc: ppc0 already exists; skipping it
sio: sio0 already exists; skipping it
Trying Read_Port at 203
Trying Read_Port at 243
Trying Read_Port at 283
Trying Read_Port at 2c3
Trying Read_Port at 303
Trying Read_Port at 343
Trying Read_Port at 383
Trying Read_Port at 3c3
sc: sc0 already exists; skipping it
vga: vga0 already exists; skipping it
isa_probe_children: disabling PnP devices
isa_probe_children: probing non-PnP devices
orm0: <ISA Option ROMs> at iomem 0xd8000-0xdbfff,0xcf000-0xcffff,0xc0000-0xcefff on isa0
pmtimer0 on isa0
adv0: not probed (disabled)
aha0: not probed (disabled)
aic0: not probed (disabled)
bt0: not probed (disabled)
cs0: not probed (disabled)
ed0: not probed (disabled)
fe0: not probed (disabled)
ie0: not probed (disabled)
lnc0: not probed (disabled)
pcic0 failed to probe at port 0x3e0 iomem 0xd0000 on isa0
pcic1: not probed (disabled)
sc0: <System console> at flags 0x180 on isa0
sc0: VGA <16 virtual consoles, flags=0x380>
sc0: fb0, kbd0, terminal emulator: sc (syscons terminal)
sio1: configured irq 3 not in bitmap of probed irqs 0
sio1: port may not be enabled
sio1: irq maps: 0x9 0x9 0x9 0x9
sio1: probe failed test(s): 0 1 2 4 6 7 9
sio1 failed to probe at port 0x2f8-0x2ff irq 3 on isa0
sio2: not probed (disabled)
sio3: not probed (disabled)
sn0: not probed (disabled)
vga0: <Generic ISA VGA> at port 0x3c0-0x3df iomem 0xa0000-0xbffff on isa0
fb0: vga0, vga, type:VGA (5), flags:0x700ff
fb0: port:0x3c0-0x3df, crtc:0x3d4, mem:0xa0000 0x20000
fb0: init mode:24, bios mode:3, current mode:24
fb0: window:0xc00b8000 size:32k gran:32k, buf:0 size:32k
vga0: vga: WARNING: video mode switching is not fully supported on this adapter
VGA parameters upon power-up
50 18 10 00 00 00 03 00 02 e7 a3 4f 67 8f 6c 1d 
24 b3 00 6f 0d 0e 00 00 07 80 49 8f 8f 28 1f 47 
6d a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
VGA parameters in BIOS for mode 24
50 18 10 00 10 00 03 00 02 67 5f 4f 50 82 55 81 
bf 1f 00 4f 0d 0e 00 00 00 00 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
EGA/VGA parameters to be used for mode 24
50 18 10 00 00 00 03 00 02 e7 a3 4f 67 8f 6c 1d 
24 b3 00 6f 0d 0e 00 00 07 80 49 8f 8f 28 1f 47 
6d a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
vt0: not probed (disabled)
isa_probe_children: probing PnP devices
Device configuration finished.
procfs registered
Timecounter "TSC" frequency 1788942957 Hz quality 800
Timecounters tick every 10.000 msec
splash: image decoder found: green_saver
cpu0: Px state: P0, 1800MHz, 30420mW, 125us, 125us
cpu0: Px state: P1, 1730MHz, 27030mW, 125us, 125us
cpu0: Px state: P2, 1663MHz, 23942mW, 125us, 125us
cpu0: Px state: P3, 1596MHz, 22939mW, 125us, 125us
cpu0: Px state: P4, 1530MHz, 22032mW, 125us, 125us
cpu0: Px state: P5, 1463MHz, 19348mW, 125us, 125us
cpu0: Px state: P6, 1396MHz, 18462mW, 125us, 125us
cpu0: Px state: P7, 1330MHz, 17589mW, 125us, 125us
cpu0: Px state: P8, 1266MHz, 15318mW, 125us, 125us
cpu0: Px state: P9, 1199MHz, 12336mW, 125us, 125us
cpu0: Px state: P10, 1133MHz, 10770mW, 125us, 125us
cpu0: Px state: P11, 1066MHz, 9120mW, 125us, 125us
cpu0: Px state: P12, 999MHz, 8547mW, 125us, 125us
cpu0: Px state: P13, 933MHz, 7982mW, 125us, 125us
cpu0: Px state: P14, 866MHz, 7409mW, 125us, 125us
cpu0: Px state: P15, 800MHz, 6845mW, 125us, 125us
cpu0: Px state: P16, 733MHz, 6271mW, 125us, 125us
cpu0: Px state: P17, 666MHz, 5698mW, 125us, 125us
cpu0: Px state: P18, 533MHz, 4560mW, 125us, 125us
cpu0: Px method: AMD K7 PowerNow!
lo0: bpf attached
acpi_cmbat0: battery initialization start
acpi_cmbat0: battery initialization done, tried 1 times
acpi_acad0: acline initialization start
acpi_acad0: On Line
acpi_acad0: acline initialization done, tried 1 times
acpi_tz0: _AC0: temperature 70.0 >= setpoint 70.0
acpi_tz0: switched from NONE to _AC0: 70.0C
ata0-master: pio=0x0c wdma=0x22 udma=0x45 cable=80pin
ata0-master: setting PIO4 on AcerLabs Aladdin chip
ata0-master: setting UDMA100 on AcerLabs Aladdin chip
ad0: <HTS726060M9AT00/MH4OA68A> ATA-6 disk at ata0-master
ad0: 57231MB (117210240 sectors), 116280 C, 16 H, 63 S, 512 B
ad0: 16 secs/int, 1 depth queue, UDMA100
ata1-master: pio=0x0c wdma=0x22 udma=0x42 cable=40pin
ata1-master: setting PIO4 on AcerLabs Aladdin chip
acd0: <Slimtype COMBO LSC-24082K/JWK2> CDRW drive at ata1 as master
acd0:  2048KB buffer, PIO4
acd0: Reads: CDR, CDRW, CDDA stream, DVDROM, DVDR, packet
acd0: Writes: CDR, CDRW, test write, burnproof
acd0: Audio: play, 255 volume levels
acd0: Mechanism: ejectable tray, unlocked
acd0: Medium: no/blank disc
(probe0:ata0:0:0:0): error 22
(probe0:ata0:0:0:0): Unretryable Error
(probe1:ata0:0:1:0): error 22
(probe1:ata0:0:1:0): Unretryable Error
(probe0:ata0:0:0:0): error 22
(probe0:ata0:0:0:0): Unretryable Error
(probe1:ata0:0:1:0): error 22
(probe1:ata0:0:1:0): Unretryable Error
(probe3:ata1:0:1:0): error 22
(probe3:ata1:0:1:0): Unretryable Error
(probe3:ata1:0:1:0): error 22
(probe3:ata1:0:1:0): Unretryable Error
(probe2:ata1:0:0:0): error 22
(probe2:ata1:0:0:0): Unretryable Error
(probe2:ata1:0:0:0): error 6
(probe2:ata1:0:0:0): Unretryable Error
(probe2:ata1:0:0:0): error 22
(probe2:ata1:0:0:0): Unretryable Error
pccard0: CIS version PC Card Standard 5.0
pccard0: CIS info: Lucent Technologies, WaveLAN/IEEE, Version 01.01, 
pccard0: Manufacturer code 0x156, product 0x2
pccard0: function 0: network adapter, ccr addr 3e0 mask 1
pccard0: function 0, config table entry 1: I/O card; irq mask ffff; iomask 6, iospace 0-3f; io16 irqpulse irqlevel
wi0: <Lucent Technologies WaveLAN/IEEE> at port 0x100-0x13f irq 3 function 0 config 1 on pccard0
wi0: [MPSAFE]
wi0: using Lucent Technologies, WaveLAN/IEEE
wi0: Lucent Firmware: Station (8.72.1)
wi0: bpf attached
wi0: Ethernet address: 00:60:1d:f2:2b:60
wi0: bpf attached
wi0: 11b rates: 1Mbps 2Mbps 5.5Mbps 11Mbps
wi0: bpf attached
(probe4:sbp0:0:0:0): error 22
(probe4:sbp0:0:0:0): Unretryable Error
(probe5:sbp0:0:1:0): error 22
(probe5:sbp0:0:1:0): Unretryable Error
(probe6:sbp0:0:2:0): error 22
(probe6:sbp0:0:2:0): Unretryable Error
(probe7:sbp0:0:3:0): error 22
(probe7:sbp0:0:3:0): Unretryable Error
(probe8:sbp0:0:4:0): error 22
(probe8:sbp0:0:4:0): Unretryable Error
(probe9:sbp0:0:5:0): error 22
(probe9:sbp0:0:5:0): Unretryable Error
(probe10:sbp0:0:6:0): error 22
(probe10:sbp0:0:6:0): Unretryable Error
pass0 at ata1 bus 0 target 0 lun 0
pass0: <Slimtype COMBO LSC-24082K JWK2> Removable CD-ROM SCSI-0 device 
pass0: 16.000MB/s transfers
(cd0:ata1:0:0:0): error 6
(cd0:ata1:0:0:0): Unretryable Error
cd0 at ata1 bus 0 target 0 lun 0
cd0: <Slimtype COMBO LSC-24082K JWK2> Removable CD-ROM SCSI-0 device 
cd0: 16.000MB/s transfers
cd0: Attempt to query device size failed: NOT READY, Medium not present
GEOM: new disk ad0
GEOM: new disk cd0
[0] f:80 typ:12 s(CHS):0/1/1 e(CHS):1023/14/63 s:63 l:30716217
[1] f:00 typ:15 s(CHS):1023/255/63 e(CHS):1023/14/63 s:30716280 l:53721360
[2] f:00 typ:165 s(CHS):1023/255/63 e(CHS):1023/14/63 s:84437640 l:32772600
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s1, start 32256 length 15726703104 end 15726735359
GEOM: Configure ad0s2, start 15726735360 length 27505336320 end 43232071679
GEOM: Configure ad0s3, start 43232071680 length 16779571200 end 60011642879
(cd0:ata1:0:0:0): error 6
(cd0:ata1:0:0:0): Unretryable Error
(cd0:ata1:0:0:0): error 6
(cd0:ata1:0:0:0): Unretryable Error
(cd0:ata1:0:0:0): error 6
(cd0:ata1:0:0:0): Unretryable Error
[0] f:ff typ:105 s(CHS):68/13/10 e(CHS):288/115/43 s:1869771365 l:168689522
[1] f:50 typ:115 s(CHS):371/114/37 e(CHS):366/32/33 s:1701519481 l:1869881465
[2] f:20 typ:116 s(CHS):371/114/37 e(CHS):372/97/50 s:2573 l:0
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:-1409286144 l:52415
[0] f:00 typ:11 s(CHS):1023/1/1 e(CHS):1023/254/63 s:63 l:20482812
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:20482875 l:1959930
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s2s1, start 32256 length 10487199744 end 10487231999
GEOM: Configure ad0s2s2, start 10487232000 length 1003484160 end 11490716159
MBREXT Slice 5 on ad0s2:
[0] f:00 typ:11 s(CHS):1023/1/1 e(CHS):1023/254/63 s:63 l:20482812
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:20482875 l:1959930
GEOM: Configure ad0s5, start 32256 length 10487199744 end 10487231999
MBREXT Slice 6 on ad0s2:
[0] f:00 typ:130 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:1959867
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:22442805 l:1959930
GEOM: Configure ad0s6, start 10487264256 length 1003451904 end 11490716159
MBREXT Slice 7 on ad0s2:
[0] f:00 typ:131 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:1959867
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:24402735 l:1959930
GEOM: Configure ad0s7, start 11490748416 length 1003451904 end 12494200319
MBREXT Slice 8 on ad0s2:
[0] f:00 typ:131 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:1959867
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:26362665 l:1959930
GEOM: Configure ad0s8, start 12494232576 length 1003451904 end 13497684479
MBREXT Slice 9 on ad0s2:
[0] f:00 typ:131 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:1959867
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:28322595 l:25398765
GEOM: Configure ad0s9, start 13497716736 length 1003451904 end 14501168639
MBREXT Slice 10 on ad0s2:
[0] f:00 typ:131 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:25398702
[1] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s10, start 14501200896 length 13004135424 end 27505336319
[0] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[1] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:80 typ:165 s(CHS):0/0/1 e(CHS):1023/254/63 s:0 l:50000
GEOM: Configure ad0s3a, start 1073741824 length 268435456 end 1342177279
GEOM: Configure ad0s3b, start 0 length 1073741824 end 1073741823
GEOM: Configure ad0s3c, start 0 length 16779571200 end 16779571199
GEOM: Configure ad0s3d, start 1342177280 length 268435456 end 1610612735
GEOM: Configure ad0s3e, start 1610612736 length 268435456 end 1879048191
GEOM: Configure ad0s3f, start 1879048192 length 14900523008 end 16779571199
[0] f:6e typ:104 s(CHS):116/100/32 e(CHS):288/101/46 s:1936028272 l:1851859059
[1] f:79 typ:121 s(CHS):357/32/43 e(CHS):0/13/10 s:1330184192 l:538976288
[2] f:20 typ:83 s(CHS):345/32/19 e(CHS):324/77/19 s:538989391 l:1398362912
[3] f:7e typ:73 s(CHS):87/1/0 e(CHS):335/78/2 s:1394627663 l:21337
[0] f:00 typ:130 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:1959867
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:22442805 l:1959930
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s2s2s1, start 32256 length 1003451904 end 1003484159
GEOM: Configure ad0s2s2s2, start 11490716160 length 1003484160 end 12494200319
MBREXT Slice 5 on ad0s2s2:
[0] f:00 typ:130 s(CHS):1023/254/63 e(CHS):1023/254/63 s:63 l:1959867
[1] f:00 typ:5 s(CHS):1023/254/63 e(CHS):1023/254/63 s:22442805 l:1959930
GEOM: Configure ad0s2s5, start 32256 length 1003451904 end 1003484159
[0] f:6e typ:104 s(CHS):116/100/32 e(CHS):288/101/46 s:1936028272 l:1851859059
[1] f:79 typ:121 s(CHS):357/32/43 e(CHS):0/13/10 s:1330184192 l:538976288
[2] f:20 typ:83 s(CHS):345/32/19 e(CHS):324/77/19 s:538989391 l:1398362912
[3] f:7e typ:73 s(CHS):87/1/0 e(CHS):335/78/2 s:1394627663 l:21337
[0] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[1] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:80 typ:165 s(CHS):0/0/1 e(CHS):1023/254/63 s:0 l:50000
[0] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[1] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:80 typ:165 s(CHS):0/0/1 e(CHS):1023/254/63 s:0 l:50000
Mounting root from ufs:/dev/ad0s3a
start_init: trying /sbin/init
acpi_ec0: info: new max delay is 900 us
acpi_ec0: info: new max delay is 920 us
acpi_tz0: switched from _AC0 to NONE: 67.0C
acpi_ec0: info: new max delay is 11000 us


More information about the freebsd-acpi mailing list