NetBSD Problem Report #37538

From buhrow@lothlorien.nfbcal.org  Fri Dec 14 06:16:51 2007
Return-Path: <buhrow@lothlorien.nfbcal.org>
Received: from mail.netbsd.org (mail.netbsd.org [204.152.190.11])
	by narn.NetBSD.org (Postfix) with ESMTP id B7DCB63BC03
	for <gnats-bugs@gnats.NetBSD.org>; Fri, 14 Dec 2007 06:16:51 +0000 (UTC)
Message-Id: <200712140604.lBE64c6j003944@lothlorien.nfbcal.org>
Date: Thu, 13 Dec 2007 22:04:38 -0800 (PST)
From: buhrow@lothlorien.nfbcal.org
Reply-To: buhrow@lothlorien.nfbcal.org
To: gnats-bugs@NetBSD.org
Subject: Problems with ACPI and BIOS interrupts on some laptops
X-Send-Pr-Version: 3.95

>Number:         37538
>Category:       kern
>Synopsis:       The BIOS on Dell D400 laptops routes interrupts properly, but doesn't report it to the ACPI tables.
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    joerg
>State:          open
>Class:          sw-bug
>Submitter-Id:   net
>Arrival-Date:   Fri Dec 14 06:20:00 +0000 2007
>Closed-Date:    
>Last-Modified:  Wed Jul 01 09:25:51 +0000 2009
>Originator:     Brian Buhrow
>Release:        NetBSD 3.0, 3.1, 4.x and -current up to i and including 2007-12-13
>Organization:
	NFB of California
>Environment:


>Description:

	On the Dell D400 laptop computer, if ACPI is enabled, the wireless
card and the sound card share irq 9.  If the interrupt load gets too high,
where too high is defined as something over 100 interupts/second, all
interrupts to irq  9 cease, and the sound card and the wireless network
card both become unusable until the application using the audio device
quits.
	Another symptom of this problem is that during the boot sequence,
you'll see something like:

. . .

LNKB: BIOS IRQ 11 for 0.31.INTB is invalid
LNKA: ACPI: Found matching pin for 0.29.INTA at func 0: 11
LNKD: ACPI: Found matching pin for 0.29.INTB at func 1: 11
LNKC: ACPI: Found matching pin for 0.29.INTC at func 2: 11
LNKH: ACPI: Found matching pin for 0.29.INTD at func 7: 11
LNKA: ACPI: Found matching pin for 0.2.INTA at func 0: 11
LNKD: ACPI: Found matching pin for 1.1.INTA at func 0: 255
LNKD: ACPI: Found matching pin for 1.1.INTA at func 1: 11
LNKB: ACPI: Found matching pin for 1.3.INTA at func 0: 11
LNKB: BIOS IRQ 11 for 1.3.INTA is invalid
LNKC: ACPI: Found matching pin for 1.0.INTA at func 0: 11


. . .

	If you look on the Net, you'll find that other folks have described
this behavior with Ubuntu Linux as well.   Their solution is to disable
ACPI, which works, but means you can't do things like monitor the
temperature of the machine, sleep the computer, check the battery status,
etc.  Fortunately, there is another way.
	When an ACPI-enabled NetBSD kernel boots, it consults the BIOS on the
host computer to find out what interrupts the BIOS has enabled for which
devices.  Once that's done, it then checks to make sure the ACPI tables
from the BIOS designate the assigned interrupts as being available for
ACPI-enabled devices, at least I think this is how things work.  In the
case of the Dell D400, and I suspect in other laptop cases, the BIOS sets
up the interrupt for the wireless and audio cards, but doesn't note that
the indicated interrupt can be used by those devices in its interrupt
tables.  NetBSD, being unavle to verify that the IRQ's are really valid,
reroutes the interrupts for these devices to other, available, irq's.
	If you apply the patch below, and add
options	ACPI_BELIEVE_BIOS
to your kernel config and rebuild, the ACPI subsystem will not question what
the BIOS has done and will permit the BIOS mappings to stay in force.
Since the mappings were really valid, all works well, and you get sound,
wireless, which you can use together again, and ACPI all in one tidy 
lightweight computer.  I wouldn't recommend this option be on by default,
but it would be nice to have it available for those of us with BIOS's which
do the right thing, but don't advertise their good deeds.  This patch
should work for NetBSD-3.x, 4.x and -current.  I've tested it under 4.x,
but verified the problem exists on 3.x and -current.

>How-To-Repeat:


	Boot an ACPI enabled kernel on a Dell D400, or another computer with a
similarly broken BIOS, and try to use the devices indicated by the invalid
messages above simultaneously.  After a while, you'll either notice all
interrupts for those devices stop, and/or they'll become intermittent.

>Fix:

Index: acpi_pci_link.c
===================================================================
RCS file: /cvsroot/src/sys/dev/acpi/acpi_pci_link.c,v
retrieving revision 1.7
diff -u -r1.7 acpi_pci_link.c
--- acpi_pci_link.c	24 Sep 2006 06:03:20 -0000	1.7
+++ acpi_pci_link.c	14 Dec 2007 06:03:25 -0000
@@ -369,6 +369,17 @@
 {
 	int i;

+#ifdef ACPI_BELIEVE_BIOS
+	/*
+	 *Some BIOS's route the interrupts correctly for the devices
+	 *they configure, but don't report that those interrupts are valid in
+	 *their interrupt table.  If this option is true, assume the BIOS
+	 *did the right thing, and always return valid.
+	 *Fixes interrupt problems with ACPI and the Dell D400 laptop
+	 */
+	return(TRUE);
+#endif
+
 	/* Invalid interrupts are never valid. */
 	if (!PCI_INTERRUPT_VALID(irq))
 		return (FALSE);

>Release-Note:

>Audit-Trail:

Responsible-Changed-From-To: kern-bug-people->joerg
Responsible-Changed-By: joerg@narn.netbsd.org
Responsible-Changed-When: Tue, 12 Feb 2008 20:40:08 +0000
Responsible-Changed-Why:
ACPI interrupt problem.

Can you please provide the DSDT e.g. from acpidump?


From: Matthias Drochner <M.Drochner@fz-juelich.de>
To: gnats-bugs@NetBSD.org
Cc: joerg@NetBSD.org, kern-bug-people@NetBSD.org,
	netbsd-bugs@NetBSD.org, gnats-admin@NetBSD.org,
	buhrow@lothlorien.nfbcal.org
Subject: Re: kern/37538 (The BIOS on Dell D400 laptops routes 
	interruptsproperly, but doesn't report it to the ACPI tables.)
Date: Tue, 12 Feb 2008 21:49:55 +0100

 joerg@NetBSD.org said:
 > Can you please provide the DSDT e.g. from acpidump? 

 while we are here - on my Dell Latitude D820, "acpidump"
 terminates suddenly after:
                 }
                 Method(_DSM, 4) {
 acpidump: strange opcode 0x96

                     If(LEqual(#


 Perhaps you know how to fix this.

 best regards
 Matthias




 -------------------------------------------------------------------
 -------------------------------------------------------------------
 Forschungszentrum Juelich GmbH
 52425 Juelich

 Sitz der Gesellschaft: Juelich
 Eingetragen im Handelsregister des Amtsgerichts Dueren Nr. HR B 3498
 Vorsitzende des Aufsichtsrats: MinDir'in Baerbel Brumme-Bothe
 Geschaeftsfuehrung: Prof. Dr. Achim Bachem (Vorsitzender),
 Dr. Ulrich Krafft (stellv. Vorsitzender), Prof. Dr. Harald Bolt,
 Dr. Sebastian M. Schmidt
 -------------------------------------------------------------------
 -------------------------------------------------------------------

From: Joerg Sonnenberger <joerg@britannica.bec.de>
To: gnats-bugs@NetBSD.org
Cc: 
Subject: Re: kern/37538 (The BIOS on Dell D400 laptops routes
	interruptsproperly, but doesn't report it to the ACPI tables.)
Date: Tue, 12 Feb 2008 21:58:04 +0100

 On Tue, Feb 12, 2008 at 08:55:02PM +0000, Matthias Drochner wrote:
 >  while we are here - on my Dell Latitude D820, "acpidump"
 >  terminates suddenly after:
 >                  }
 >                  Method(_DSM, 4) {
 >  acpidump: strange opcode 0x96
 >  
 >                      If(LEqual(#
 >  
 >  
 >  Perhaps you know how to fix this.

 It doesn't implement some opcodes of ACPI 3.0. I've started working on
 that a while ago, but never had the drive to finish it.

 Joerg

State-Changed-From-To: open->feedback
State-Changed-By: joerg@NetBSD.org
State-Changed-When: Wed, 21 May 2008 22:12:41 +0000
State-Changed-Why:
Please provide the DSDT. I think this is the same issue as PR 37001.


From: Joerg Sonnenberger <joerg@britannica.bec.de>
To: gnats-bugs@NetBSD.org
Cc: 
Subject: Re: kern/37538 (The BIOS on Dell D400 laptops routes interrupts
	properly, but doesn't report it to the ACPI tables.)
Date: Thu, 29 May 2008 22:16:02 +0200

 --XsQoSWH+UP9D9v3l
 Content-Type: text/plain; charset=us-ascii
 Content-Disposition: inline

 On Wed, May 21, 2008 at 10:12:42PM +0000, joerg@NetBSD.org wrote:
 > Synopsis: The BIOS on Dell D400 laptops routes interrupts properly,
 > but doesn't report it to the ACPI tables.

 Please try the attached patch.

 Joerg

 --XsQoSWH+UP9D9v3l
 Content-Type: text/plain; charset=us-ascii
 Content-Disposition: attachment; filename="acpi-ambigous-prt.diff"

 Index: mpacpi.c
 ===================================================================
 RCS file: /data/repo/netbsd/src/sys/arch/x86/x86/mpacpi.c,v
 retrieving revision 1.58
 diff -u -p -r1.58 mpacpi.c
 --- mpacpi.c	26 Apr 2008 15:13:00 -0000	1.58
 +++ mpacpi.c	29 May 2008 20:14:26 -0000
 @@ -690,7 +690,7 @@ mpacpi_pciroute(struct mpacpi_pcibus *mp
  	ACPI_PCI_ROUTING_TABLE *ptrp;
          ACPI_HANDLE linkdev;
  	char *p;
 -	struct mp_intr_map *mpi;
 +	struct mp_intr_map *mpi, *iter;
  	struct mp_bus *mpb;
  	struct pic *pic;
  	unsigned dev;
 @@ -714,11 +714,25 @@ mpacpi_pciroute(struct mpacpi_pcibus *mp
  			break;
  		dev = ACPI_HIWORD(ptrp->Address);

 -		mpi = &mp_intrs[mpacpi_intr_index++];
 +		mpi = &mp_intrs[mpacpi_intr_index];
  		mpi->bus_pin = (dev << 2) | ptrp->Pin;
  		mpi->bus = mpb;
  		mpi->type = MPS_INTTYPE_INT;

 +		/*
 +		 * First check if an entry for this device/pin combination
 +		 * was already found.  Some DSDTs have more than one entry
 +		 * and it seems that the first is generally the right one.
 +		 */
 +		for (iter = mpb->mb_intrs; iter != NULL; iter = iter->next) {
 +			if (iter->bus_pin == mpi->bus_pin)
 +				break;
 +		}
 +		if (iter != NULL)
 +			continue;
 +
 +		++mpacpi_intr_index;
 +
  		if (ptrp->Source[0] != 0) {
  			if (mp_verbose > 1)
  				printf("pciroute: dev %d INT%c on lnkdev %s\n",

 --XsQoSWH+UP9D9v3l--

State-Changed-From-To: feedback->closed
State-Changed-By: joerg@NetBSD.org
State-Changed-When: Tue, 29 Jul 2008 13:23:13 +0000
State-Changed-Why:
A patch was committed and no feedback provided.
Assume fixed.


From: buhrow@lothlorien.nfbcal.org (Brian Buhrow)
To: gnats-bugs@NetBSD.org
Cc: buhrow@lothlorien.nfbcal.org
Subject: Re: kern/37538: Problems with ACPI and BIOS interrupts on some laptops
Date: Wed, 1 Jul 2009 01:05:24 -0700

 	Hello.  I'm sorry to have to report that the problem described in this
 bug is not fixed with NetBSD-5.x.  The patch shown in the beginning of this
 bug report still does the trick, however, and I've been able to upgrade the
 machine to 5.x with the patch applied.  I was not able to report the state
 of the requested patches because this machine has been in production use
 for the past year and a half, and I could not afford to have it out of
 service for testing during that period.
 	I have, however, now ben able to provide the asl description of the
 acpi dstp table, which is included below.  If kern/37001 is fixed in 5.x, then this is
 definitely not the same bug.
 	All my other notes from this bug, as originally reported, still apply,
 including the invalid messages shown.
 So, this problem exists in all versions of NetBSD from 3.x to 5.x, and
 probably -current as well, though I haven't tried.
 It would be nice to get a real fix for this problem in, but I know how hard
 it can be to work on machines that are hard to test with, and because this
 is my working laptop, there are not many windows of opportunity for me to
 fool around with test kernels on it.
 	Here, for what it's worth is the dstp table.
 Any light anyone can shed on the problem based on this output would be very
 much appreciated.

 -thanks
 -Brian


 /*
 RSD PTR: Checksum=114, OEMID=DELL, RsdtAddress=0x1fef0000
  */
 /*
 RSDT: Length=44, Revision=1, Checksum=224,
 	OEMID=DELL, OEM Table ID=CPi R, OEM Revision=0x27d5061c,
 	Creator ID=ASL, Creator Revision=0x61
  */
 /*
 	Entries={ 0x1fef0400, 0x1fef0800 }
  */
 /*
 	DSDT=0x1fef0c00
 	INT_MODEL=PIC
 	SCI_INT=9
 	SMI_CMD=0xb2, ACPI_ENABLE=0x70, ACPI_DISABLE=0x71, S4BIOS_REQ=0x97
 	PM1a_EVT_BLK=0x800-0x803
 	PM1a_CNT_BLK=0x804-0x805
 	PM2_CNT_BLK=0x820-0x820
 	PM2_TMR_BLK=0x808-0x80b
 	PM2_GPE0_BLK=0x828-0x82f
 	P_LVL2_LAT=50ms, P_LVL3_LAT=50ms
 	FLUSH_SIZE=0, FLUSH_STRIDE=0
 	DUTY_OFFSET=1, DUTY_WIDTH=3
 	DAY_ALRM=0, MON_ALRM=0, CENTURY=0
 	Flags={WBINVD,PROC_C1,PWR_BUTTON,SLP_BUTTON,DCK_CAP}
  */
 /*
 DSDT: Length=12481, Revision=1, Checksum=48,
 	OEMID=INT430, OEM Table ID=SYSFexxx, OEM Revision=0x1001,
 	Creator ID=MSFT, Creator Revision=0x100000e
  */
 DefinitionBlock ("acpi_dst.aml", "DSDT", 0x1, "INT430", "SYSFexxx", 0x1001)
 {
 Name(VERS, Package(0x03) {
     "Project\x3a\x20DELL\x20Mojave",
     "Date\x3a\x2001\x2f28\x2f1998",
     "Ver\x3a\x201.00.04",
 })
 Event(EJTD)
 Name(MISC, Buffer(0x09) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
 CreateByteField(MISC, 0x00, MIS0)
 CreateByteField(MISC, 0x02, MIS2)
 CreateByteField(MISC, 0x03, MIS3)
 CreateByteField(MISC, 0x04, MIS4)
 CreateByteField(MISC, 0x05, MIS5)
 CreateByteField(MISC, 0x06, MIS6)
 CreateByteField(MISC, 0x07, MIS7)
 CreateByteField(MISC, 0x08, MIS8)
 Mutex(SMIX, 1)
 Method(SMI, 2) {
     Acquire(SMIX, 0xffff)
     Store(Arg1, \_SB.SMIA)
     Store(Arg0, \_SB.SMIC)
     Store(\_SB.SMIC, Local0)
     While(LNot(LEqual(Local0, 0x00))) {
         Store(\_SB.SMIC, Local0)
     }
     Store(\_SB.SMIA, Local1)
     Release(SMIX)
     Return(Local1)
 }
 Name(SXX0, Buffer(0x0100) { })
 Name(SXX1, Buffer(0x08) { })
 CreateWordField(SXX1, 0x00, SXX2)
 CreateWordField(SXX1, 0x04, SXX3)
 Method(SX10) {
     Acquire(SMIX, 0xffff)
     Store(0x00, SXX2)
 }
 Method(SX30, 1) {
     Store(SXX2, Local0)
     Increment(Local0)
     If(LNot(LGreater(Local0, SizeOf(SXX0)))) {
         CreateByteField(SXX0, SXX2, SX20)
         Store(Arg0, SX20)
         Store(Local0, SXX2)
     }
 }
 Method(SX31, 1) {
     Store(SXX2, Local0)
     Add(Local0, 0x02, Local0)
     If(LNot(LGreater(Local0, SizeOf(SXX0)))) {
         CreateWordField(SXX0, SXX2, SX21)
         Store(Arg0, SX21)
         Store(Local0, SXX2)
     }
 }
 Method(SX32, 1) {
     Store(SXX2, Local0)
     Add(Local0, 0x04, Local0)
     If(LNot(LGreater(Local0, SizeOf(SXX0)))) {
         CreateDWordField(SXX0, SXX2, SX22)
         Store(Arg0, SX22)
         Store(Local0, SXX2)
     }
 }
 Method(SX33, 2) {
     If(LLess(Arg1, SizeOf(Arg0))) {
         CreateByteField(Arg0, Arg1, SX20)
         SX30(SX20)
     }
 }
 Method(SX34, 2) {
     Store(0x00, Local0)
     While(LLess(Local0, Arg1)) {
         SX33(Arg0, Local0)
         Increment(Local0)
     }
 }
 Method(SXX6, 2) {
     Store(Arg1, \_SB.SMIA)
     Store(Arg0, \_SB.SMIC)
     Store(\_SB.SMIC, Local0)
     While(LNot(LEqual(Local0, 0x00))) {
         Store(\_SB.SMIC, Local0)
     }
     Return(\_SB.SMIA)
 }
 Method(SXX5, 2) {
     If(LLess(Arg1, SizeOf(Arg0))) {
         CreateByteField(Arg0, Arg1, SX20)
         SXX6(0x7c, SX20)
     }
 }
 Method(SXX4) {
     SXX6(0x7b, 0x00)
     Store(0x00, Local0)
     While(LLess(Local0, SXX2)) {
         SXX5(SXX0, Local0)
         Increment(Local0)
     }
 }
 Method(SXX8, 2) {
     If(LLess(Arg1, SizeOf(Arg0))) {
         CreateByteField(Arg0, Arg1, SX20)
         Store(SXX6(0x7d, 0x00), SX20)
     }
 }
 Method(SXX7) {
     Store(0x00, Local0)
     While(LLess(Local0, SXX3)) {
         Add(SXX2, Local0, Local1)
         SXX8(SXX0, Local1)
         Increment(Local0)
     }
 }
 Method(SX11) {
     SXX4()
     Store(SXX6(0x79, 0x00), SXX3)
     Add(SXX2, SXX3, Local0)
     If(LLess(SizeOf(SXX0), Local0)) {
         Store(SizeOf(SXX0), Local0)
         Subtract(Local0, SXX2, Local0)
         Store(Local0, SXX3)
     }
     SXX7()
 }
 Method(SX40) {
     Store(SXX2, Local0)
     Increment(Local0)
     If(LNot(LGreater(Local0, SizeOf(SXX0)))) {
         CreateByteField(SXX0, SXX2, SX20)
         Store(Local0, SXX2)
         Return(SX20)
     }
     Return(0x00)
 }
 Method(SX41) {
     Store(SXX2, Local0)
     Add(Local0, 0x02, Local0)
     If(LNot(LGreater(Local0, SizeOf(SXX0)))) {
         CreateWordField(SXX0, SXX2, SX21)
         Store(Local0, SXX2)
         Return(SX21)
     }
     Return(0x00)
 }
 Method(SX42) {
     Store(SXX2, Local0)
     Add(Local0, 0x04, Local0)
     If(LNot(LGreater(Local0, SizeOf(SXX0)))) {
         CreateDWordField(SXX0, SXX2, SX22)
         Store(Local0, SXX2)
         Return(SX22)
     }
     Return(0x00)
 }
 Method(SX43, 2) {
     If(LLess(Arg1, SizeOf(Arg0))) {
         CreateByteField(Arg0, Arg1, SX20)
         Store(SX40(), SX20)
     }
 }
 Method(SX44, 2) {
     Store(0x00, Local0)
     While(LLess(Local0, Arg1)) {
         SX43(Arg0, Local0)
         Increment(Local0)
     }
 }
 Method(SX45) {
     Store(SX40(), Local0)
     Name(SX23, Buffer(Local0) { })
     SX44(SX23, Local0)
     Return(SX23)
 }
 Method(SX12) {
     Release(SMIX)
 }
 Method(PNPQ, 1) {
     SX10()
     SX30(0x00)
     SX30(0x02)
     SX30(Arg0)
     SX11()
     Store(SX40(), Local0)
     SX12()
     Return(Local0)
 }
 Method(PNPD, 1) {
     SX10()
     SX30(0x00)
     SX30(0x03)
     SX30(Arg0)
     SX11()
     SX12()
 }
 Method(PNPG, 1) {
     SX10()
     SX30(0x00)
     SX30(0x00)
     SX30(Arg0)
     SX11()
     Name(PGET, Buffer(SXX3) { })
     SX44(PGET, SXX3)
     SX12()
     Return(PGET)
 }
 Method(PNPS, 2) {
     SX10()
     SX30(0x00)
     SX30(0x01)
     SX30(Arg0)
     SX34(Arg1, SizeOf(Arg1))
     SX11()
     SX12()
 }
 Method(PSW, 2) {
     SX10()
     SX30(0x06)
     SX30(Arg0)
     SX30(Arg1)
     SX11()
     SX12()
 }
 Method(DSS, 2) {
     SX10()
     SX30(0x08)
     SX30(Arg0)
     SX32(Arg1)
     SX11()
     SX12()
 }
 Method(GMEM) {
     SX10()
     SX30(0x07)
     SX11()
     Store(SX42(), Local0)
     SX12()
     Return(Local0)
 }
 Method(GORL) {
     SX10()
     SX30(0x09)
     SX11()
     Store(SX42(), Local0)
     SX12()
     Return(Local0)
 }
 Name(W98S, "Microsoft\x20Windows")
 Name(NT5S, "Microsoft\x20Windows\x20NT")
 Name(WINM, "Microsoft\x20WindowsME\x3a\x20Millennium\x20Edition")
 Name(WXP, "Windows\x202001")
 Method(GETC, 2) {
     CreateByteField(Arg0, Arg1, TCHR)
     Return(TCHR)
 }
 Method(STRE, 2) {
     Name(STR1, Buffer(0x50) { })
     Name(STR2, Buffer(0x50) { })
     Store(Arg0, STR1)
     Store(Arg1, STR2)
     Store(Zero, Local0)
     Store(One, Local1)
     While(Local1) {
         Store(GETC(STR1, Local0), Local1)
         Store(GETC(STR2, Local0), Local2)
         If(LNot(LEqual(Local1, Local2))) {
             Return(Zero)
         }
         Increment(Local0)
     }
     Return(One)
 }
 Method(OSID) {
     If(LEqual(MIS3, 0x00)) {
         Store(0x01, MIS3)
         If(CondRefOf(\_OSI, Local0)) {
             If(\_OSI(WXP)) {
                 Store(0x10, MIS3)
             }
         }
         Else {
             If(STRE(\_OS, W98S)) {
                 Store(0x02, MIS3)
             }
             If(STRE(\_OS, NT5S)) {
                 Store(0x08, MIS3)
             }
             If(STRE(\_OS, WINM)) {
                 Store(0x04, MIS3)
             }
         }
     }
     Return(MIS3)
 }
 Method(SOST) {
     SX10()
     SX30(0x0a)
     OSID()
     SX30(MIS3)
     SX11()
     SX12()
 }
 Name(WAKE, 0x00)
 Method(NEVT) {
     Store(SMI(0x8c, 0x00), Local0)
     If(And(Local0, 0x01, )) {
         Notify(\_SB.PBTN, 0x80)
     }
     If(And(Local0, 0x02, )) {
         EJTE()
     }
     If(And(Local0, 0x04, )) {
         LIDE()
     }
     If(And(Local0, 0x08, )) {
         PWRE()
     }
     If(And(Local0, 0x10, )) {
         DCKE()
     }
     If(And(Local0, 0x20, )) {
         BAYE()
     }
     If(And(Local0, 0x40, )) {
         Notify(\_SB.SBTN, 0x80)
     }
     If(And(Local0, 0x80, )) {
         SMIE()
     }
 }
 Method(EJTE) {
     SMI(0xa6, 0x01)
     Notify(\_SB.PCI0.PCIE.GDCK, 0x01)
 }
 Method(LIDE) {
     Store(SMI(0x43, 0x00), Local0)
     If(LNot(LEqual(Local0, 0x00))) {
         If(LEqual(OSID(), 0x10)) {
             Notify(\_SB.PCI0, 0x00)
             Sleep(0x03e8)
         }
         Else {
             If(LEqual(OSID(), 0x08)) {
                 Notify(\_SB.PCI0.VID, 0x00)
                 Notify(\_SB.PCI0.VID2, 0x00)
                 Sleep(0x02ee)
             }
         }
         Notify(\_SB.PCI0.VID, 0x80)
     }
     Notify(\_SB.LID, 0x80)
 }
 Method(PWRE) {
     Store(SMI(0x98, 0x00), Local0)
     XOr(Local0, MIS0, Local1)
     And(Local0, Or(0x01, Or(0x02, 0x10, ), ), MIS0)
     If(And(Local1, 0x01, )) {
         Notify(\_SB.AC, 0x80)
     }
     And(MIS0, 0x02, Local2)
     If(And(Local1, 0x02, )) {
         If(Local2) {
             Notify(\_SB.BAT0, 0x81)
         }
         Else {
             Notify(\_SB.BAT0, 0x81)
         }
     }
     If(And(Local1, 0x04, )) {
         If(Local2) {
             Notify(\_SB.BAT0, 0x80)
         }
     }
     If(And(Local1, 0x08, )) {
         If(Local2) {
             Notify(\_SB.BAT0, 0x80)
         }
     }
 }
 Method(DCKE) {
     Store(SMI(0x65, 0x22), Local0)
     And(Local0, 0x08, MIS8)
     Store(SMI(0x87, 0x00), Local0)
     XOr(Local0, MIS7, Local1)
     Store(Local0, MIS7)
     Store(Local0, MIS2)
     If(Local1) {
         If(Local0) {
             Notify(\_SB.PCI0.PCIE.GDCK, 0x00)
         }
         Else {
             SMI(0x8d, 0x00)
             If(MIS8) {
                 Signal(EJTD)
             }
             Else {
                 Notify(\_SB.PCI0.PCIE.GDCK, 0x01)
             }
         }
     }
 }
 Method(BAYE) {
     Store(SMI(0x86, 0x00), Local0)
     If(And(Local0, 0x02, )) {
         SMI(0x90, 0x01)
     }
     Else {
         SMI(0x90, 0x00)
     }
     SMI(0xba, 0x00)
 }
 Method(SMIE) {
     Store(SMI(0x96, 0x00), Local0)
     If(And(Local0, 0x01, )) {
         Notify(\_TZ.THM, 0x80)
     }
     If(And(Local0, 0x20, )) {
         Notify(\_SB.PCI0.VID, 0x81)
     }
     If(And(Local0, 0x02, )) {
         If(LEqual(OSID(), 0x10)) {
             Notify(\_SB.PCI0, 0x00)
             Sleep(0x03e8)
         }
         Else {
             If(LEqual(OSID(), 0x08)) {
                 Notify(\_SB.PCI0.VID, 0x00)
                 Notify(\_SB.PCI0.VID2, 0x00)
                 Sleep(0x02ee)
             }
         }
         Notify(\_SB.PCI0.VID, 0x80)
     }
     If(And(Local0, 0x04, )) {
         Notify(\_SB.BAT0, 0x81)
     }
     If(And(Local0, 0x08, )) {
         Notify(\_PR.CPU0, 0x80)
     }
     If(And(Local0, 0x40, )) {
         Store(0x00, MIS5)
     }
 }
 Method(\_PTS, 1) {
     SMI(0x8a, Arg0)
 }
 Method(\_WAK, 1) {
     SMI(0xa7, MIS2)
     SMI(0x9a, Arg0)
     If(LEqual(Arg0, 0x04)) {
         Notify(\_SB.PBTN, 0x02)
         Store(SMI(0x98, 0x00), MIS0)
         Store(0x01, MIS4)
         SOST()
     }
     Notify(\_SB.AC, 0x80)
     Store(SMI(0x87, 0x00), Local0)
     XOr(Local0, MIS2, Local1)
     If(Local1) {
         If(Local0) {
             Notify(\_SB.PCI0.PCIE.GDCK, 0x00)
         }
         Else {
             If(LEqual(OSID(), 0x02)) {
                 SMI(0x8d, 0x00)
                 Notify(\_SB.PCI0.PCIE.GDCK, 0x01)
             }
         }
     }
     Store(Local0, MIS2)
     SMI(0xa6, 0x00)
 }
 Method(NWAK) {
     Store(0x01, WAKE)
     Store(SMI(0x89, 0x00), Local0)
     Store(0x00, Local1)
     If(LEqual(Local0, 0x00)) {
         Store(0x01, Local1)
     }
     If(And(Local0, 0x01, )) {
         Store(0x01, Local1)
     }
     If(And(Local0, 0x02, )) {
         LIDE()
     }
     If(And(Local0, 0x10, )) {
         Notify(\_SB.PCI0.PCIE.GDCK, 0x02)
     }
     If(And(Local0, 0x40, )) {
         Notify(\_SB.PCI0.PCIE.GDCK, 0x01)
     }
     If(And(Local0, 0x20, )) {
         If(LEqual(OSID(), 0x02)) {
             Store(0x01, Local1)
         }
     }
     Notify(\_SB.BAT0, 0x81)
     If(Local1) {
         Notify(\_SB.PBTN, 0x02)
     }
     Store(0x00, WAKE)
 }
 Scope(\_GPE) {
     Method(_L1D) {
         NEVT()
     }
     Method(_L1C) {
         NWAK()
     }
     Method(_L0B) {
         Store(0x00, Local0)
         Notify(\_SB.PCI0, 0x02)
     }
     Method(_L18) {
         Store(0x00, Local0)
     }
     Method(_L03) {
         Notify(\_SB.PCI0.USB0, 0x02)
     }
     Method(_L04) {
         Notify(\_SB.PCI0.USB1, 0x02)
     }
     Method(_L0C) {
         Notify(\_SB.PCI0.USB2, 0x02)
     }
     Method(_L0D) {
         Notify(\_SB.PCI0.USB3, 0x02)
     }
     Method(_L05) {
         Notify(\_SB.PCI0.MODM, 0x02)
     }
 }
 Name(CRS0, Buffer(0x0101) { })
 CreateByteField(CRS0, 0x0100, CRS1)
 Method(CRS3) {
     Store(0x00, CRS1)
 }
 Method(CRS4, 1) {
     CreateByteField(CRS0, CRS1, CRS2)
     Store(Arg0, CRS2)
     Increment(CRS1)
 }
 Method(CRS5, 1) {
     CreateWordField(CRS0, CRS1, CRS2)
     Store(Arg0, CRS2)
     Increment(CRS1)
     Increment(CRS1)
 }
 Method(CRS6, 1) {
     CreateDWordField(CRS0, CRS1, CRS2)
     Store(Arg0, CRS2)
     Add(CRS1, 0x04, CRS1)
 }
 Method(CR_0, 3) {
     CRS4(0x86)
     CRS5(0x09)
     CRS4(Arg0)
     CRS6(Arg1)
     CRS6(Arg2)
 }
 Method(CR_1, 4) {
     CRS4(0x47)
     CRS4(0x01)
     CRS5(Arg0)
     CRS5(Arg1)
     CRS4(Arg2)
     CRS4(Arg3)
 }
 Method(CR_2, 2) {
     CRS4(0x88)
     CRS5(0x0d)
     CRS4(0x02)
     CRS4(0x0c)
     CRS4(0x00)
     CRS5(0x00)
     CRS5(Arg0)
     Add(Arg0, Arg1, Local0)
     Decrement(Local0)
     CRS5(Local0)
     CRS5(0x00)
     CRS5(Arg1)
 }
 Method(CR_3, 2) {
     CRS4(0x88)
     CRS5(0x0d)
     CRS4(0x01)
     CRS4(0x0c)
     CRS4(0x03)
     CRS5(0x00)
     CRS5(Arg0)
     Add(Arg0, Arg1, Local0)
     Decrement(Local0)
     CRS5(Local0)
     CRS5(0x00)
     CRS5(Arg1)
 }
 Method(CR_4, 2) {
     CRS4(0x87)
     CRS5(0x17)
     CRS4(0x00)
     CRS4(0x0c)
     CRS4(0x03)
     CRS6(0x00)
     CRS6(Arg0)
     Add(Arg0, Arg1, Local0)
     Decrement(Local0)
     CRS6(Local0)
     CRS6(0x00)
     CRS6(Arg1)
 }
 Method(CR_5) {
     CRS5(0x79)
 }
 Scope(\_PR) {
     Processor(CPU0, 0, 0x8e0, 0x6) {
         Name(PDC0, 0xf0000000)
         Method(_PDC, 1) {
             CreateDWordField(Arg0, 0x08, CAP0)
             Store(CAP0, PDC0)
         }
         Method(_PCT) {
             If(LEqual(And(PDC0, 0x01, ), 0x01)) {
                 Return(Package(0x02) {
                     Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x40, 0x0, 0x0, 0x99, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                     Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x10, 0x0, 0x0, 0x98, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 })
             }
             Else {
                 Return(Package(0x02) {
                     Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x10, 0x0, 0x0, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                     Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 })
             }
         }
         Name(PSSX, Package(0x08) {
             Package(0x06) {
                 0x0640,
                 0x6590,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x0640,
                 0x6590,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x05dc,
                 0x61a8,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x0578,
                 0x5dc0,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x0514,
                 0x59d8,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x04b0,
                 0x55f0,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x044c,
                 0x5208,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
             Package(0x06) {
                 0x03e8,
                 0x4e20,
                 0x0a,
                 0x0a,
                 0x00,
                 0x00,
             },
         })
         Name(PSSN, 0x00)
         Method(_PSS) {
             SX10()
             If(LEqual(And(PDC0, 0x01, ), 0x01)) {
                 SX30(0x0c)
             }
             Else {
                 SX30(0x0b)
             }
             SX11()
             Store(SX40(), PSSN)
             Subtract(0x08, 0x08, Local1)
             While(LLess(Local1, 0x08)) {
                 Store(SX42(), Index(DerefOf(Index(PSSX, Local1, )), 0x00, ))
                 Store(SX42(), Index(DerefOf(Index(PSSX, Local1, )), 0x01, ))
                 Store(SX42(), Index(DerefOf(Index(PSSX, Local1, )), 0x02, ))
                 Store(SX42(), Index(DerefOf(Index(PSSX, Local1, )), 0x03, ))
                 Store(SX41(), Index(DerefOf(Index(PSSX, Local1, )), 0x04, ))
                 Store(SX41(), Index(DerefOf(Index(PSSX, Local1, )), 0x05, ))
                 Increment(Local1)
             }
             SX12()
             Subtract(0x08, 0x08, Local1)
             While(LLess(Local1, 0x08)) {
                 Increment(Local1)
             }
             Return(PSSX)
         }
         Method(_PPC) {
             Subtract(0x08, PSSN, Local0)
             Add(Local0, SMI(0xad, 0x00), Local0)
             Return(Local0)
         }
         Name(DCST, Package(0x05) {
             0x04,
             Package(0x04) {
                 Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 0x01,
                 0x01,
                 0x03e8,
             },
             Package(0x04) {
                 Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x14, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 0x02,
                 0x01,
                 0x01f4,
             },
             Package(0x04) {
                 Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x15, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 0x03,
                 0x55,
                 0xfa,
             },
             Package(0x04) {
                 Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x16, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 0x03,
                 0xb9,
                 0x64,
             },
         })
         Name(NCST, Package(0x03) {
             0x02,
             Package(0x04) {
                 Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 0x01,
                 0x01,
                 0x03e8,
             },
             Package(0x04) {
                 Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0x14, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
                 0x02,
                 0x01,
                 0x01f4,
             },
         })
         Method(_CST) {
             Store(SMI(0x5e, 0x00), Local0)
             If(LEqual(Local0, 0x00)) {
                 Return(NCST)
             }
             Return(DCST)
         }
     }
 }
 Name(\_S0, Package(0x03) {
     0x00,
     0x00,
     0x00,
 })
 Name(\_S1, Package(0x03) {
     0x02,
     0x00,
     0x00,
 })
 Name(\_S3, Package(0x03) {
     0x05,
     0x00,
     0x00,
 })
 Name(\_S4, Package(0x03) {
     0x07,
     0x00,
     0x00,
 })
 Name(\_S5, Package(0x03) {
     0x07,
     0x00,
     0x00,
 })
 Scope(\_TZ) {
     ThermalZone(THM) {
         Method(_CRT) {
             Store(0x63, Local0)
             Multiply(Local0, 0x0a, Local0)
             Add(Local0, 0x0aac, Local0)
             Return(Local0)
         }
         Method(_TMP) {
             Store(GINF(0x04), Local0)
             Return(Local0)
         }
         Method(GINF, 1) {
             SX10()
             SX30(Arg0)
             SX11()
             Store(SX41(), Local0)
             SX12()
             If(LLess(Local0, 0x0ba6)) {
                 Store(0x0ba6, Local0)
             }
             Return(Local0)
         }
     }
 }
 Scope(\_SB) {
     OperationRegion(SMIR, SystemIO, 0xb2, 0x02)
     Field(SMIR, ByteAcc, NoLock, Preserve) {
         SMIC,	8,
         SMID,	8
     }
     OperationRegion(SMR2, SystemIO, 0x86, 0x01)
     Field(SMR2, ByteAcc, NoLock, Preserve) {
         SMIA,	8
     }
     Device(AC) {
         Name(_HID, "ACPI0003")
         Name(_PCL, Package(0x02) {
             \_SB,
             BAT0,
         })
         Method(_PSR) {
             Store(SMI(0x85, 0x00), Local0)
             And(Local0, 0x01, Local0)
             Return(Local0)
         }
         Method(_STA) {
             Return(0x0f)
         }
     }
     Name(BIFP, Package(0x0d) {
     })
     Method(BIF, 1) {
         SX10()
         SX30(0x01)
         SX30(Arg0)
         SX11()
         Store(SX42(), Index(BIFP, 0x00, ))
         Store(SX42(), Index(BIFP, 0x01, ))
         Store(SX42(), Index(BIFP, 0x02, ))
         Store(SX42(), Index(BIFP, 0x03, ))
         Store(SX42(), Index(BIFP, 0x04, ))
         Store(SX42(), Index(BIFP, 0x05, ))
         Store(SX42(), Index(BIFP, 0x06, ))
         Store(SX42(), Index(BIFP, 0x07, ))
         Store(SX42(), Index(BIFP, 0x08, ))
         Store(SX45(), Index(BIFP, 0x09, ))
         Store(SX45(), Index(BIFP, 0x0a, ))
         Store(SX45(), Index(BIFP, 0x0b, ))
         Store(SX45(), Index(BIFP, 0x0c, ))
         SX12()
         Return(BIFP)
     }
     Device(BAT0) {
         Name(_HID, 0x0a0cd041)
         Name(_UID, 0x01)
         Name(_PCL, Package(0x01) {
             \_SB,
         })
         Method(_STA) {
             And(MIS0, 0x02, Local0)
             If(Local0) {
                 Return(0x1f)
             }
             Return(0x0f)
         }
         Method(_BIF) {
             Return(BIF(0x01))
         }
         Method(_BST) {
             SX10()
             SX30(0x02)
             SX30(0x01)
             SX11()
             Name(BST0, Package(0x04) {
             })
             Store(SX42(), Index(BST0, 0x00, ))
             Store(SX42(), Index(BST0, 0x01, ))
             Store(SX42(), Index(BST0, 0x02, ))
             Store(SX42(), Index(BST0, 0x03, ))
             SX12()
             Return(BST0)
         }
         Method(_BTP, 1) {
             SX10()
             SX30(0x03)
             SX30(0x01)
             SX32(Arg0)
             SX11()
             SX12()
             Sleep(0xfa)
         }
     }
     Device(LID) {
         Name(_HID, 0x0d0cd041)
         Method(_LID) {
             Store(SMI(0x84, 0x00), Local0)
             Return(Local0)
         }
         Name(_PRW, Package(0x02) {
             0x1c,
             0x03,
         })
         Method(_PSW, 1) {
             PSW(Arg0, 0x02)
         }
     }
     Device(PBTN) {
         Name(_HID, 0x0c0cd041)
         Name(_PRW, Package(0x02) {
             0x1c,
             0x04,
         })
         Method(_PSW, 1) {
             PSW(Arg0, 0x01)
         }
     }
     Device(SBTN) {
         Name(_HID, 0x0e0cd041)
     }
     Device(MB1) {
         Name(_HID, 0x010cd041)
         Name(_UID, 0x01)
         Method(_CRS) {
             CRS3()
             CR_0(0x01, 0x00, 0x0009fc00)
             CR_0(0x01, 0x0009fc00, 0x0400)
             If(LOr(LEqual(OSID(), 0x08), LEqual(OSID(), 0x10))) {
                 Store(GORL(), Local0)
                 CR_0(0x00, 0x000c0000, Local0)
             }
             CR_0(0x00, 0x000e0000, 0x00020000)
             Store(GMEM(), Local0)
             Subtract(Local0, 0x00010000, Local1)
             CR_0(0x01, 0x00100000, Local1)
             Add(Local1, 0x00100000, Local1)
             CR_0(0x01, Local1, 0x00010000)
             CR_0(0x00, 0xfec10000, 0x00010000)
             CR_0(0x00, 0xfeda0000, 0x00060000)
             CR_0(0x00, 0xffb00000, 0x00100000)
             CR_5()
             Return(CRS0)
         }
     }
     Device(PCI0) {
         Name(_HID, 0x030ad041)
         Name(_ADR, 0x00)
         Name(_PRW, Package(0x02) {
             0x0b,
             0x03,
         })
         Method(_INI) {
             Store(SMI(0x98, 0x00), MIS0)
             And(MIS0, Or(0x01, Or(0x02, 0x10, ), ), MIS0)
             Store(SMI(0x87, 0x00), MIS2)
             Store(0x01, MIS4)
             SOST()
         }
         Method(_CRS) {
             CRS3()
             CR_2(0x00, 0x0100)
             CR_3(0x00, 0x0cf8)
             CR_1(0x0cf8, 0x0cf8, 0x01, 0x08)
             CR_3(0x0d00, 0xf300)
             CR_4(0x000a0000, 0x00020000)
             CR_4(0x000d0000, 0x00010000)
             Add(0x00100000, GMEM(), Local0)
             Subtract(0xfec10000, Local0, Local1)
             If(Local1) {
                 CR_4(Local0, Local1)
             }
             Subtract(0xfeda0000, 0xfec20000, Local1)
             CR_4(0xfec20000, Local1)
             Subtract(0xffb00000, 0xfee00000, Local1)
             CR_4(0xfee00000, Local1)
             CR_5()
             Return(CRS0)
         }
         Device(MB2) {
             Name(_HID, 0x010cd041)
             Name(_UID, 0x02)
             Name(CRS, Buffer(0x3d) {0x47, 0x1, 0x92, 0x0, 0x92, 0x0, 0x2, 0x1, 0x47, 0x1, 0xb2, 0x0, 0xb2, 0x0, 0x2, 0x1, 0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x10, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x10, 0x2, 0x22, 0x4, 0x0, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x10, 0x2, 0x47, 0x1, 0x0, 0x8, 0x0, 0x8, 0x10, 0x6, 0x47, 0x1, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x79, 0x0 })
             Method(_CRS) {
                 Return(CRS)
             }
         }
         Device(MB3) {
             Name(_HID, 0x010cd041)
             Name(_UID, 0x03)
             Name(CRS, Buffer(0x4a) {0x47, 0x1, 0x0, 0xf4, 0x0, 0xf4, 0x1, 0xff, 0x47, 0x1, 0x86, 0x0, 0x86, 0x0, 0x2, 0x1, 0x47, 0x1, 0xb3, 0x0, 0xb3, 0x0, 0x1, 0x1, 0x47, 0x1, 0x6, 0x8, 0x6, 0x8, 0x2, 0x2, 0x47, 0x1, 0x10, 0x8, 0x10, 0x8, 0x10, 0x50, 0x47, 0x1, 0x60, 0x8, 0x60, 0x8, 0x10, 0x20, 0x47, 0x1, 0x80, 0x8, 0x80, 0x8, 0x10, 0x40, 0x47, 0x1, 0xc0, 0x8, 0xc0, 0x8, 0x10, 0x20, 0x47, 0x1, 0xe0, 0x8, 0xe0, 0x8, 0x10, 0x20, 0x79, 0x0 })
             Method(_CRS) {
                 Return(CRS)
             }
         }
         Device(ISAB) {
             Name(_ADR, 0x001f0000)
             OperationRegion(PIR1, PCI_Config, 0x60, 0x04)
             OperationRegion(PIR2, PCI_Config, 0x68, 0x04)
             OperationRegion(FDIS, PCI_Config, 0xf2, 0x02)
             Device(PS2M) {
                 Name(_HID, 0x130fd041)
                 Name(CRS, Buffer(0x05) {0x22, 0x0, 0x10, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(KBC) {
                 Name(_HID, 0x0303d041)
                 Name(CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x10, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x4, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(RTC) {
                 Name(_HID, 0x000bd041)
                 Name(CRS, Buffer(0x15) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x10, 0x2, 0x22, 0x0, 0x1, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x2, 0x6, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(TMR) {
                 Name(_HID, 0x0001d041)
                 Name(CRS, Buffer(0x15) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x10, 0x4, 0x22, 0x1, 0x0, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x10, 0x4, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(SPKR) {
                 Name(_HID, 0x0008d041)
                 Name(CRS, Buffer(0x22) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 0x1, 0x47, 0x1, 0x63, 0x0, 0x63, 0x0, 0x1, 0x1, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x1, 0x1, 0x47, 0x1, 0x67, 0x0, 0x67, 0x0, 0x1, 0x1, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(MB4) {
                 Name(_HID, 0x010cd041)
                 Name(_UID, 0x04)
                 Name(CRS, Buffer(0x1a) {0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x2, 0x2, 0x47, 0x1, 0x4e, 0x0, 0x4e, 0x0, 0x2, 0x2, 0x47, 0x1, 0x0, 0x9, 0x0, 0x9, 0x10, 0x80, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(PIC) {
                 Name(_HID, 0xd041)
                 Name(CRS, Buffer(0x72) {0x47, 0x1, 0x24, 0x0, 0x24, 0x0, 0x4, 0x2, 0x47, 0x1, 0x28, 0x0, 0x28, 0x0, 0x4, 0x2, 0x47, 0x1, 0x2c, 0x0, 0x2c, 0x0, 0x4, 0x2, 0x47, 0x1, 0x30, 0x0, 0x30, 0x0, 0x4, 0x2, 0x47, 0x1, 0x34, 0x0, 0x34, 0x0, 0x4, 0x2, 0x47, 0x1, 0x38, 0x0, 0x38, 0x0, 0x4, 0x2, 0x47, 0x1, 0x3c, 0x0, 0x3c, 0x0, 0x4, 0x2, 0x47, 0x1, 0xa4, 0x0, 0xa4, 0x0, 0x4, 0x2, 0x47, 0x1, 0xa8, 0x0, 0xa8, 0x0, 0x4, 0x2, 0x47, 0x1, 0xac, 0x0, 0xac, 0x0, 0x4, 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x4, 0x2, 0x47, 0x1, 0xb4, 0x0, 0xb4, 0x0, 0x4, 0x2, 0x47, 0x1, 0xb8, 0x0, 0xb8, 0x0, 0x4, 0x2, 0x47, 0x1, 0xbc, 0x0, 0xbc, 0x0, 0x4, 0x2, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(MAD) {
                 Name(_HID, 0x0002d041)
                 Name(CRS, Buffer(0x3d) {0x2a, 0x10, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x10, 0x10, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x10, 0x6, 0x47, 0x1, 0x87, 0x0, 0x87, 0x0, 0x1, 0x9, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x10, 0x20, 0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x10, 0x10, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0, 0x10, 0x2, 0x47, 0x1, 0x93, 0x0, 0x93, 0x0, 0x1, 0xd, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(COPR) {
                 Name(_HID, 0x040cd041)
                 Name(CRS, Buffer(0x0d) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x10, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
                 Method(_CRS) {
                     Return(CRS)
                 }
             }
             Device(UAR1) {
                 Name(_HID, 0x0105d041)
                 Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 Method(_STA) {
                     Store(PNPQ(0x02), Local1)
                     Return(Local1)
                 }
                 Method(_DIS) {
                     PNPD(0x02)
                 }
                 Method(_CRS) {
                     Return(PNPG(0x02))
                 }
                 Method(_PRS) {
                     Name(BUF0, Buffer(0x3b) {0x31, 0x5, 0x23, 0x58, 0x10, 0x11, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x8, 0x8, 0x31, 0x5, 0x23, 0x58, 0x10, 0x11, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8, 0x31, 0x5, 0x23, 0x58, 0x10, 0x11, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x31, 0x5, 0x23, 0x58, 0x10, 0x11, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x38, 0x79, 0x0 })
                     Return(BUF0)
                 }
                 Method(_SRS, 1) {
                     PNPS(0x02, Arg0)
                 }
             }
             Device(ECP) {
                 Name(_HID, 0x0104d041)
                 Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 Method(_STA) {
                     Store(PNPQ(0x01), Local1)
                     Return(Local1)
                 }
                 Method(_DIS) {
                     PNPD(0x01)
                 }
                 Method(_CRS) {
                     Return(PNPG(0x01))
                 }
                 Name(_PRS, Buffer(0xd2) {0x30, 0x2a, 0x0, 0x0, 0x22, 0xb8, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x8, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x8, 0x4, 0x30, 0x2a, 0xe, 0x0, 0x22, 0x80, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x8, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x8, 0x4, 0x30, 0x2a, 0x0, 0x0, 0x22, 0xb8, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8, 0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x8, 0x4, 0x30, 0x2a, 0xe, 0x0, 0x22, 0xb8, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8, 0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x8, 0x4, 0x30, 0x2a, 0x0, 0x0, 0x22, 0xb8, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x4, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x4, 0x4, 0x30, 0x2a, 0xe, 0x0, 0x22, 0xb8, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x4, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x4, 0x4, 0x30, 0x2a, 0x0, 0x0, 0x22, 0x0, 0x0, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x8, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x8, 0x4, 0x30, 0x2a, 0x0, 0x0, 0x22, 0x0, 0x0, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8!
  , 0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x8, 0x4, 0x30, 0x2a, 0x0, 0x0, 0x22, 0x0, 0x0, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x4, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x4, 0x4, 0x38, 0x79, 0x0 })
                 Method(_SRS, 1) {
                     PNPS(0x01, Arg0)
                 }
             }
             Device(IRDA) {
                 Name(_HID, 0x10f0a34d)
                 Method(_STA) {
                     Store(PNPQ(0x03), Local0)
                     Return(Local0)
                 }
                 Method(_DIS) {
                     PNPD(0x03)
                 }
                 Method(_CRS) {
                     Return(PNPG(0x03))
                 }
                 Name(_PRS, Buffer(0x0100) {0x30, 0x22, 0x10, 0x0, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0xe, 0x0, 0x30, 0x22, 0x10, 0x0, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0x0, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0xe, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0xe, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0xe, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0xe, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0x0, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8, 0x47, !
  0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0x0, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0x0, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x47, 0x1, 0x70, 0x2, 0x0, 0x4, 0x8, 0x8, 0x2a, 0x0, 0x0, 0x30, 0x22, 0x58, 0x10, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x2a, 0x0, 0x0, 0x38, 0x79, 0x0 })
                 Method(_SRS, 1) {
                     PNPS(0x03, Arg0)
                 }
             }
         }
         Device(USB0) {
             Name(_ADR, 0x001d0000)
             Method(_S0D) {
                 Store(SMI(0x85, 0x00), Local0)
                 And(Local0, 0x01, Local0)
                 If(LEqual(Local0, 0x00)) {
                     Return(0x03)
                 }
                 Else {
                     Return(0x00)
                 }
             }
             Name(XPRW, Package(0x02) {
                 0x03,
                 0x01,
             })
             Method(_PRW) {
                 Return(XPRW)
             }
             Device(HUB0) {
                 Name(_ADR, 0x00)
                 Device(CH0) {
                     Name(_ADR, 0x01)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH1) {
                     Name(_ADR, 0x02)
                 }
             }
         }
         Device(USB1) {
             Name(_ADR, 0x001d0001)
             Method(_S0D) {
                 Store(SMI(0x85, 0x00), Local0)
                 And(Local0, 0x01, Local0)
                 If(LEqual(Local0, 0x00)) {
                     Return(0x03)
                 }
                 Else {
                     Return(0x00)
                 }
             }
             Name(XPRW, Package(0x02) {
                 0x04,
                 0x01,
             })
             Name(YPRW, Package(0x02) {
                 0x04,
                 0x00,
             })
             Method(_PRW) {
                 If(LEqual(OSID(), 0x04)) {
                     Return(YPRW)
                 }
                 Else {
                     Return(XPRW)
                 }
             }
             Device(HUB1) {
                 Name(_ADR, 0x00)
                 Device(CH10) {
                     Name(_ADR, 0x01)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH11) {
                     Name(_ADR, 0x02)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
             }
         }
         Device(USB2) {
             Name(_ADR, 0x001d0002)
             Method(_S0D) {
                 Store(SMI(0x85, 0x00), Local0)
                 And(Local0, 0x01, Local0)
                 If(LEqual(Local0, 0x00)) {
                     Return(0x03)
                 }
                 Else {
                     Return(0x00)
                 }
             }
             Name(XPRW, Package(0x02) {
                 0x0c,
                 0x01,
             })
             Method(_PRW) {
                 Return(XPRW)
             }
             Device(HUB2) {
                 Name(_ADR, 0x00)
                 Device(CH20) {
                     Name(_ADR, 0x01)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH21) {
                     Name(_ADR, 0x02)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
             }
         }
         Device(USB3) {
             Name(_ADR, 0x001d0007)
             Method(_S0D) {
                 Store(SMI(0x85, 0x00), Local0)
                 And(Local0, 0x01, Local0)
                 If(LEqual(Local0, 0x00)) {
                     Return(0x03)
                 }
                 Else {
                     Return(0x00)
                 }
             }
             Name(_S1D, 0x02)
             Name(_S3D, 0x02)
             Name(XPRW, Package(0x02) {
                 0x0d,
                 0x01,
             })
             Method(_PRW) {
                 Return(XPRW)
             }
             Device(HUB3) {
                 Name(_ADR, 0x00)
                 Device(CH30) {
                     Name(_ADR, 0x01)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH31) {
                     Name(_ADR, 0x02)
                 }
                 Device(CH32) {
                     Name(_ADR, 0x03)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH33) {
                     Name(_ADR, 0x04)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH34) {
                     Name(_ADR, 0x05)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH35) {
                     Name(_ADR, 0x06)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH36) {
                     Name(_ADR, 0x07)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
                 Device(CH37) {
                     Name(_ADR, 0x08)
                     Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
                 }
             }
         }
         Scope(\_SB) {
         }
         Name(PIC0, Package(0x09) {
             Package(0x04) {
                 0x001fffff,
                 0x00,
                 \_SB.PCI0.LNKA,
                 0x00,
             },
             Package(0x04) {
                 0x001fffff,
                 0x01,
                 \_SB.PCI0.LNKB,
                 0x00,
             },
             Package(0x04) {
                 0x001fffff,
                 0x02,
                 \_SB.PCI0.LNKC,
                 0x00,
             },
             Package(0x04) {
                 0x001fffff,
                 0x03,
                 \_SB.PCI0.LNKD,
                 0x00,
             },
             Package(0x04) {
                 0x001dffff,
                 0x00,
                 \_SB.PCI0.LNKA,
                 0x00,
             },
             Package(0x04) {
                 0x001dffff,
                 0x01,
                 \_SB.PCI0.LNKD,
                 0x00,
             },
             Package(0x04) {
                 0x001dffff,
                 0x02,
                 \_SB.PCI0.LNKC,
                 0x00,
             },
             Package(0x04) {
                 0x001dffff,
                 0x03,
                 \_SB.PCI0.LNKH,
                 0x00,
             },
             Package(0x04) {
                 0x0002ffff,
                 0x00,
                 \_SB.PCI0.LNKA,
                 0x00,
             },
         })
         Method(_PRT) {
             Store(PIC0, Local0)
             Return(Local0)
         }
         Field(\_SB.PCI0.ISAB.PIR1, ByteAcc, NoLock, Preserve) {
             PIRA,	8,
             PIRB,	8,
             PIRC,	8,
             PIRD,	8
         }
         Field(\_SB.PCI0.ISAB.PIR2, ByteAcc, NoLock, Preserve) {
             PIRE,	8,
             PIRF,	8,
             PIRG,	8,
             PIRH,	8
         }
         Device(LNKA) {
             Name(_HID, 0x0f0cd041)
             Name(_UID, 0x01)
             Name(_PRS, Buffer(0x06) {0x23, 0x0, 0xe, 0x18, 0x79, 0x0 })
             Method(_STA) {
                 Store(PIRA, Local0)
                 And(Local0, 0x80, Local0)
                 If(LEqual(Local0, 0x80)) {
                     Return(0x09)
                 }
                 Return(0x0b)
             }
             Method(_DIS) {
                 Store(PIRA, Local0)
                 Or(Local0, 0x80, Local0)
                 Store(Local0, PIRA)
             }
             Method(_CRS) {
                 Name(BUFA, Buffer(0x06) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                 CreateWordField(BUFA, 0x01, IRA)
                 Store(PIRA, Local0)
                 And(Local0, 0x8f, Local0)
                 If(LLess(Local0, 0x80)) {
                     And(Local0, 0x0f, )
                     Store(0x01, Local1)
                     ShiftLeft(Local1, Local0, Local1)
                     Store(Local1, IRA)
                 }
                 Return(BUFA)
             }
             Method(_SRS, 1) {
                 CreateWordField(Arg0, 0x01, IRQA)
                 FindSetLeftBit(IRQA, Local0)
                 Decrement(Local0)
                 Store(Local0, PIRA)
             }
         }
         Device(LNKB) {
             Name(_HID, 0x0f0cd041)
             Name(_UID, 0x02)
             Name(_PRS, Buffer(0x06) {0x23, 0xa0, 0x0, 0x18, 0x79, 0x0 })
             Method(_STA) {
                 Store(PIRB, Local0)
                 And(Local0, 0x80, Local0)
                 If(LEqual(Local0, 0x80)) {
                     Return(0x09)
                 }
                 Return(0x0b)
             }
             Method(_DIS) {
                 Store(PIRB, Local0)
                 Or(Local0, 0x80, Local0)
                 Store(Local0, PIRB)
             }
             Method(_CRS) {
                 Name(BUFB, Buffer(0x06) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                 CreateWordField(BUFB, 0x01, IRB)
                 Store(PIRB, Local0)
                 And(Local0, 0x8f, Local0)
                 If(LLess(Local0, 0x80)) {
                     And(Local0, 0x0f, )
                     Store(0x01, Local1)
                     ShiftLeft(Local1, Local0, Local1)
                     Store(Local1, IRB)
                 }
                 Return(BUFB)
             }
             Method(_SRS, 1) {
                 CreateWordField(Arg0, 0x01, IRQB)
                 FindSetLeftBit(IRQB, Local0)
                 Decrement(Local0)
                 Store(Local0, PIRB)
             }
         }
         Device(LNKC) {
             Name(_HID, 0x0f0cd041)
             Name(_UID, 0x03)
             Name(_PRS, Buffer(0x06) {0x23, 0x0, 0xe, 0x18, 0x79, 0x0 })
             Method(_STA) {
                 Store(PIRC, Local0)
                 And(Local0, 0x80, Local0)
                 If(LEqual(Local0, 0x80)) {
                     Return(0x09)
                 }
                 Return(0x0b)
             }
             Method(_DIS) {
                 Store(PIRC, Local0)
                 Or(Local0, 0x80, Local0)
                 Store(Local0, PIRC)
             }
             Method(_CRS) {
                 Name(BUFC, Buffer(0x06) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                 CreateWordField(BUFC, 0x01, IRC)
                 Store(PIRC, Local0)
                 And(Local0, 0x8f, Local0)
                 If(LLess(Local0, 0x80)) {
                     And(Local0, 0x0f, )
                     Store(0x01, Local1)
                     ShiftLeft(Local1, Local0, Local1)
                     Store(Local1, IRC)
                 }
                 Return(BUFC)
             }
             Method(_SRS, 1) {
                 CreateWordField(Arg0, 0x01, IRQC)
                 FindSetLeftBit(IRQC, Local0)
                 Decrement(Local0)
                 Store(Local0, PIRC)
             }
         }
         Device(LNKD) {
             Name(_HID, 0x0f0cd041)
             Name(_UID, 0x04)
             Name(_PRS, Buffer(0x06) {0x23, 0xa0, 0xe, 0x18, 0x79, 0x0 })
             Method(_STA) {
                 Store(PIRD, Local0)
                 And(Local0, 0x80, Local0)
                 If(LEqual(Local0, 0x80)) {
                     Return(0x09)
                 }
                 Return(0x0b)
             }
             Method(_DIS) {
                 Store(PIRD, Local0)
                 Or(Local0, 0x80, Local0)
                 Store(Local0, PIRD)
             }
             Method(_CRS) {
                 Name(BUFD, Buffer(0x06) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                 CreateWordField(BUFD, 0x01, IRD)
                 Store(PIRD, Local0)
                 And(Local0, 0x8f, Local0)
                 If(LLess(Local0, 0x80)) {
                     And(Local0, 0x0f, )
                     Store(0x01, Local1)
                     ShiftLeft(Local1, Local0, Local1)
                     Store(Local1, IRD)
                 }
                 Return(BUFD)
             }
             Method(_SRS, 1) {
                 CreateWordField(Arg0, 0x01, IRQD)
                 FindSetLeftBit(IRQD, Local0)
                 Decrement(Local0)
                 Store(Local0, PIRD)
             }
         }
         Device(LNKE) {
             Name(_HID, 0x0f0cd041)
             Name(_UID, 0x05)
             Name(_PRS, Buffer(0x06) {0x23, 0xf8, 0xde, 0x18, 0x79, 0x0 })
             Method(_STA) {
                 Store(PIRE, Local0)
                 And(Local0, 0x80, Local0)
                 If(LEqual(Local0, 0x80)) {
                     Return(0x09)
                 }
                 Return(0x0b)
             }
             Method(_DIS) {
                 Store(PIRE, Local0)
                 Or(Local0, 0x80, Local0)
                 Store(Local0, PIRE)
             }
             Method(_CRS) {
                 Name(BUFE, Buffer(0x06) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                 CreateWordField(BUFE, 0x01, IRE)
                 Store(PIRE, Local0)
                 And(Local0, 0x8f, Local0)
                 If(LLess(Local0, 0x80)) {
                     And(Local0, 0x0f, )
                     Store(0x01, Local1)
                     ShiftLeft(Local1, Local0, Local1)
                     Store(Local1, IRE)
                 }
                 Return(BUFE)
             }
             Method(_SRS, 1) {
                 CreateWordField(Arg0, 0x01, IRQE)
                 FindSetLeftBit(IRQE, Local0)
                 Decrement(Local0)
                 Store(Local0, PIRE)
             }
         }
         Device(LNKH) {
             Name(_HID, 0x0f0cd041)
             Name(_UID, 0x08)
             Name(_PRS, Buffer(0x06) {0x23, 0xf8, 0xde, 0x18, 0x79, 0x0 })
             Method(_STA) {
                 Store(PIRH, Local0)
                 And(Local0, 0x80, Local0)
                 If(LEqual(Local0, 0x80)) {
                     Return(0x09)
                 }
                 Return(0x0b)
             }
             Method(_DIS) {
                 Store(PIRH, Local0)
                 Or(Local0, 0x80, Local0)
                 Store(Local0, PIRH)
             }
             Method(_CRS) {
                 Name(BUFH, Buffer(0x06) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                 CreateWordField(BUFH, 0x01, IRH)
                 Store(PIRH, Local0)
                 And(Local0, 0x8f, Local0)
                 If(LLess(Local0, 0x80)) {
                     And(Local0, 0x0f, )
                     Store(0x01, Local1)
                     ShiftLeft(Local1, Local0, Local1)
                     Store(Local1, IRH)
                 }
                 Return(BUFH)
             }
             Method(_SRS, 1) {
                 CreateWordField(Arg0, 0x01, IRQH)
                 FindSetLeftBit(IRQH, Local0)
                 Decrement(Local0)
                 Store(Local0, PIRH)
             }
         }
         Device(IDE0) {
             Name(_ADR, 0x001f0001)
             Method(_STA) {
                 Return(0x0f)
             }
             Device(PRI) {
                 Name(_ADR, 0x00)
                 Method(_STA) {
                     Return(0x0f)
                 }
             }
             Device(SEC0) {
                 Name(_ADR, 0x01)
                 Method(_STA) {
                     Return(0x0f)
                 }
             }
         }
         Device(AUD) {
             Name(_ADR, 0x001f0005)
         }
         Device(MODM) {
             Name(_ADR, 0x001f0006)
             Name(_PRW, Package(0x02) {
                 0x05,
                 0x03,
             })
         }
         Device(VID) {
             Name(_ADR, 0x00020000)
             Method(_DOS, 1) {
                 Store(Arg0, MIS4)
                 SMI(0x9e, MIS4)
             }
             Method(_DOD) {
                 Return(Package(0x04) {
                     0x00010100,
                     0x00010200,
                     0x00010400,
                     0x00010300,
                 })
             }
             Device(TV) {
                 Method(_ADR) {
                     Return(0x0200)
                 }
                 Method(_DCS) {
                     Store(SMI(0x8e, 0x04), Local0)
                     Return(Local0)
                 }
                 Method(_DGS) {
                     Store(SMI(0x99, 0x04), Local0)
                     Return(Local0)
                 }
                 Method(_DSS, 1) {
                     DSS(0x04, Arg0)
                 }
             }
             Device(CRT) {
                 Method(_ADR) {
                     Return(0x0100)
                 }
                 Method(_DCS) {
                     Store(SMI(0x8e, 0x02), Local0)
                     Return(Local0)
                 }
                 Method(_DGS) {
                     Store(SMI(0x99, 0x02), Local0)
                     Return(Local0)
                 }
                 Method(_DSS, 1) {
                     DSS(0x02, Arg0)
                 }
             }
             Device(CRT2) {
                 Method(_ADR) {
                     Store(SMI(0x6d, 0x00), Local0)
                     If(LEqual(Local0, 0x01)) {
                         Return(0x0120)
                     }
                     Else {
                         Return(0x0101)
                     }
                 }
                 Method(_DCS) {
                     Store(SMI(0x8e, 0x20), Local0)
                     Return(Local0)
                 }
                 Method(_DGS) {
                     Store(SMI(0x99, 0x20), Local0)
                     Return(Local0)
                 }
                 Method(_DSS, 1) {
                     DSS(0x20, Arg0)
                 }
             }
             Device(LCD) {
                 Method(_ADR) {
                     Return(0x0400)
                 }
                 Method(_DCS) {
                     Store(SMI(0x8e, 0x01), Local0)
                     Return(Local0)
                 }
                 Method(_DGS) {
                     Store(SMI(0x99, 0x01), Local0)
                     Return(Local0)
                 }
                 Method(_DSS, 1) {
                     DSS(0x01, Arg0)
                 }
             }
             Device(DVI) {
                 Method(_ADR) {
                     Return(0x0300)
                 }
                 Method(_DCS) {
                     Store(SMI(0x8e, 0x08), Local0)
                     Return(Local0)
                 }
                 Method(_DGS) {
                     Store(SMI(0x99, 0x08), Local0)
                     Return(Local0)
                 }
                 Method(_DSS, 1) {
                     DSS(0x08, Arg0)
                 }
             }
         }
         Device(VID2) {
             Name(_ADR, 0x00020001)
             Method(_DOS, 1) {
             }
             Method(_DOD) {
                 Return(Package(0x00) {
                 })
             }
         }
         Device(MB7) {
             Name(_HID, 0x010cd041)
             Name(_UID, 0x07)
             Method(_STA) {
                 If(LEqual(OSID(), 0x08)) {
                     Return(0x0b)
                 }
                 If(LEqual(OSID(), 0x10)) {
                     Return(0x0b)
                 }
                 Return(0x00)
             }
             Name(_CRS, Buffer(0x03f2) {0x47, 0x1, 0xb0, 0x7, 0xb0, 0x7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x7, 0xc0, 0x7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xb, 0xb0, 0xb, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xb, 0xc0, 0xb, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xf, 0xb0, 0xf, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xf, 0xc0, 0xf, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x13, 0xb0, 0x13, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x13, 0xc0, 0x13, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x17, 0xb0, 0x17, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x17, 0xc0, 0x17, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x1b, 0xb0, 0x1b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x1b, 0xc0, 0x1b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x1f, 0xb0, 0x1f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x1f, 0xc0, 0x1f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x23, 0xb0, 0x23, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x23, 0xc0, 0x23, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x27, 0xb0, 0x27, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x27, 0xc0, 0x27, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x2b, 0xb0, 0x2b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x2b, 0xc0, 0x2b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x2f, 0xb0, 0x2!
  f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x2f, 0xc0, 0x2f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x33, 0xb0, 0x33, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x33, 0xc0, 0x33, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x37, 0xb0, 0x37, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x37, 0xc0, 0x37, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x3b, 0xb0, 0x3b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x3b, 0xc0, 0x3b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x3f, 0xb0, 0x3f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x3f, 0xc0, 0x3f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x43, 0xb0, 0x43, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x43, 0xc0, 0x43, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x47, 0xb0, 0x47, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x47, 0xc0, 0x47, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x4b, 0xb0, 0x4b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x4b, 0xc0, 0x4b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x4f, 0xb0, 0x4f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x4f, 0xc0, 0x4f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x53, 0xb0, 0x53, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x53, 0xc0, 0x53, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x57, 0xb0, 0x57, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x57, 0xc0, 0x57, 0x10, 0x2!
  0, 0x47, 0x1, 0xb0, 0x5b, 0xb0, 0x5b, 0x10, 0xc, 0x47, 0x1, 0x!
  c0, 0x5b
 , 0xc0, 0x5b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x5f, 0xb0, 0x5f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x5f, 0xc0, 0x5f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x63, 0xb0, 0x63, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x63, 0xc0, 0x63, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x67, 0xb0, 0x67, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x67, 0xc0, 0x67, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x6b, 0xb0, 0x6b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x6b, 0xc0, 0x6b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x6f, 0xb0, 0x6f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x6f, 0xc0, 0x6f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x73, 0xb0, 0x73, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x73, 0xc0, 0x73, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x77, 0xb0, 0x77, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x77, 0xc0, 0x77, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x7b, 0xb0, 0x7b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x7b, 0xc0, 0x7b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x7f, 0xb0, 0x7f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x7f, 0xc0, 0x7f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x83, 0xb0, 0x83, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x83, 0xc0, 0x83, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x87, 0xb0, 0x87!
  , 0x10, 0xc, 0x47, 0x1, 0xc0, 0x87, 0xc0, 0x87, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x8b, 0xb0, 0x8b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x8b, 0xc0, 0x8b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x8f, 0xb0, 0x8f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x8f, 0xc0, 0x8f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x93, 0xb0, 0x93, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x93, 0xc0, 0x93, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x97, 0xb0, 0x97, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x97, 0xc0, 0x97, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x9b, 0xb0, 0x9b, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x9b, 0xc0, 0x9b, 0x10, 0x20, 0x47, 0x1, 0xb0, 0x9f, 0xb0, 0x9f, 0x10, 0xc, 0x47, 0x1, 0xc0, 0x9f, 0xc0, 0x9f, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xa3, 0xb0, 0xa3, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xa3, 0xc0, 0xa3, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xa7, 0xb0, 0xa7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xa7, 0xc0, 0xa7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xab, 0xb0, 0xab, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xab, 0xc0, 0xab, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xaf, 0xb0, 0xaf, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xaf, 0xc0, 0xaf, 0x10, 0x20!
  , 0x47, 0x1, 0xb0, 0xb3, 0xb0, 0xb3, 0x10, 0xc, 0x47, 0x1, 0xc!
  0, 0xb3,
  0xc0, 0xb3, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xb7, 0xb0, 0xb7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xb7, 0xc0, 0xb7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xbb, 0xb0, 0xbb, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xbb, 0xc0, 0xbb, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xbf, 0xb0, 0xbf, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xbf, 0xc0, 0xbf, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xc3, 0xb0, 0xc3, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xc3, 0xc0, 0xc3, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xc7, 0xb0, 0xc7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xc7, 0xc0, 0xc7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xcb, 0xb0, 0xcb, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xcb, 0xc0, 0xcb, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xcf, 0xb0, 0xcf, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xcf, 0xc0, 0xcf, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xd3, 0xb0, 0xd3, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xd3, 0xc0, 0xd3, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xd7, 0xb0, 0xd7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xd7, 0xc0, 0xd7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xdb, 0xb0, 0xdb, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xdb, 0xc0, 0xdb, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xdf, 0xb0, 0xdf,!
   0x10, 0xc, 0x47, 0x1, 0xc0, 0xdf, 0xc0, 0xdf, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xe3, 0xb0, 0xe3, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xe3, 0xc0, 0xe3, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xe7, 0xb0, 0xe7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xe7, 0xc0, 0xe7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xeb, 0xb0, 0xeb, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xeb, 0xc0, 0xeb, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xef, 0xb0, 0xef, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xef, 0xc0, 0xef, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xf3, 0xb0, 0xf3, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xf3, 0xc0, 0xf3, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xf7, 0xb0, 0xf7, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xf7, 0xc0, 0xf7, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xfb, 0xb0, 0xfb, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xfb, 0xc0, 0xfb, 0x10, 0x20, 0x47, 0x1, 0xb0, 0xff, 0xb0, 0xff, 0x10, 0xc, 0x47, 0x1, 0xc0, 0xff, 0xc0, 0xff, 0x10, 0x20, 0x79, 0x0 })
         }
         Device(PCIE) {
             Name(_ADR, 0x001e0000)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x04,
             })
             Name(PICE, Package(0x07) {
                 Package(0x04) {
                     0x0001ffff,
                     0x00,
                     \_SB.PCI0.LNKD,
                     0x00,
                 },
                 Package(0x04) {
                     0x0001ffff,
                     0x01,
                     \_SB.PCI0.LNKD,
                     0x00,
                 },
                 Package(0x04) {
                     0x0003ffff,
                     0x00,
                     \_SB.PCI0.LNKB,
                     0x00,
                 },
                 Package(0x04) {
                     0x0003ffff,
                     0x01,
                     \_SB.PCI0.LNKD,
                     0x00,
                 },
                 Package(0x04) {
                     0xffff,
                     0x00,
                     \_SB.PCI0.LNKC,
                     0x00,
                 },
                 Package(0x04) {
                     0x0008ffff,
                     0x00,
                     \_SB.PCI0.LNKB,
                     0x00,
                 },
                 Package(0x04) {
                     0x0008ffff,
                     0x01,
                     \_SB.PCI0.LNKB,
                     0x00,
                 },
             })
             Method(_PRT) {
                 Store(PICE, Local0)
                 Return(Local0)
             }
             Device(CRD0) {
                 Name(_ADR, 0x00010000)
                 Method(_INI) {
                     SMI(0x95, 0x04)
                 }
                 Name(_S1D, 0x00)
                 Name(_S3D, 0x03)
             }
             Device(CRD1) {
                 Name(_ADR, 0x00010001)
                 Method(_INI) {
                     SMI(0x9d, 0x04)
                 }
                 Name(_S1D, 0x00)
                 Name(_S3D, 0x03)
             }
             Device(GDCK) {
                 Name(_HID, 0x150cd041)
                 Method(_STA) {
                     If(And(MIS5, 0x01, )) {
                         Store(SMI(0x87, 0x00), Local2)
                         If(Local2) {
                             Notify(\_SB.PCI0.PCIE.GDCK, 0x00)
                             Return(0x00)
                         }
                     }
                     Store(SMI(0x87, 0x00), Local0)
                     If(Local0) {
                         Return(0x0f)
                     }
                     Return(0x00)
                 }
                 Method(_UID) {
                     SX10()
                     SX30(0x05)
                     SX30(OSID())
                     SX11()
                     Store(SX42(), Local0)
                     SX12()
                     Return(Local0)
                 }
                 Method(_BDN) {
                     Store(SMI(0x87, 0x00), Local0)
                     If(LEqual(Local0, 0x01)) {
                         Return(0x0c80ac10)
                     }
                     If(LEqual(Local0, 0x02)) {
                         Return(0x0d80ac10)
                     }
                     Return(0x00)
                 }
                 Method(_EJ0, 1) {
                     Store(SMI(0x87, 0x00), MIS7)
                     If(MIS7) {
                         SMI(0xa6, 0x02)
                         SMI(0x49, 0x01)
                         Wait(EJTD, 0xa000)
                         SMI(0x49, 0x00)
                     }
                     Return(0x00)
                 }
                 Method(_EJ3, 1) {
                     SMI(0xa6, 0x01)
                     Return(0x00)
                 }
                 Method(_EJ4, 1) {
                     SMI(0xa6, 0x01)
                     Return(0x00)
                 }
                 Method(_DCK, 1) {
                     If(Arg0) {
                         SMI(0x8d, 0x01)
                         Store(0x00, MIS5)
                     }
                     Else {
                         SMI(0x8d, 0x00)
                         Store(0x00, MIS2)
                         Store(0x01, MIS5)
                     }
                     Return(0x01)
                 }
             }
             Device(DCKS) {
                 Name(_ADR, 0x00080000)
                 Name(_EJD, "\\\x5fSB\x5f.PCI0.PCIE.GDCK")
             }
         }
     }
 }

 }
 /*
 ASF!: Length=91, Revision=16, Checksum=127,
 	OEMID=DELL, OEM Table ID=CPi R, OEM Revision=0x27d5061c,
 	Creator ID=ASL, Creator Revision=0x61
  */

State-Changed-From-To: closed->open
State-Changed-By: joerg@NetBSD.org
State-Changed-When: Wed, 01 Jul 2009 09:25:51 +0000
State-Changed-Why:
Feedback provided, problem persists.


>Unformatted:

NetBSD Home
NetBSD PR Database Search

(Contact us) $NetBSD: query-full-pr,v 1.39 2013/11/01 18:47:49 spz Exp $
$NetBSD: gnats_config.sh,v 1.8 2006/05/07 09:23:38 tsutsui Exp $
Copyright © 1994-2007 The NetBSD Foundation, Inc. ALL RIGHTS RESERVED.