P2120 Problems

From: Andrew Marks <atm_at_amrx.net>
Date: Fri, 16 Jan 2004 12:47:13 -0800
I wrote before about my USB 2.0 not working on my Fujitsu P2120.  This
is still the case with current as of January 13, 2004.  There also seem
to be some problems with acpi, and some devices with no drivers. I am
attaching my verbose dmesg, my acpidump -d, and my kernel config.  Any
ideas for fixing any of this would be awsome.  I did tinker with the
acpi asl stuff, but nothing I did effected anything.  Please feel free
to request more information.

holly crap!  I just realized how large acpidump -d is.  Please forgive
me, but I am posting anyway.

-Andrew Marks

dmesg
-------------------------------------------------------------------

Copyright (c) 1992-2004 The FreeBSD Project.
Copyright (c) 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
	The Regents of the University of California. All rights reserved.
FreeBSD 5.2-CURRENT #6: Wed Jan 14 20:07:01 PST 2004
    root_at_joshua:/usr/obj/usr/src/sys/P2120
Preloaded elf kernel "/boot/kernel/kernel" at 0xc0876000.
Preloaded elf module "/boot/kernel/acpi.ko" at 0xc0876250.
Calibrating clock(s) ... i8254 clock: 1193135 Hz
CLK_USE_I8254_CALIBRATION not specified - using default frequency
Timecounter "i8254" frequency 1193182 Hz quality 0
Calibrating TSC clock ... TSC clock: 925439631 Hz
CPU: Transmeta(tm) Crusoe(tm) Processor TM5800 (925.44-MHz 586-class CPU)
  Origin = "GenuineTMx86"  Id = 0x543
  Processor revision 1.4.1.0
  Code Morphing Software revision 4.3.2-9-566
  20030108 13:03 official release 28.0.3-4.3.2#1
  LongRun mode: 2  <933MHz 1350mV 100%>
real memory  = 519962624 (495 MB)
Physical memory chunk(s):
0x0000000000001000 - 0x000000000009bfff, 634880 bytes (155 pages)
0x0000000000100000 - 0x00000000003fffff, 3145728 bytes (768 pages)
0x0000000000c26000 - 0x000000001e6fffff, 497917952 bytes (121562 pages)
avail memory = 499085312 (475 MB)
bios32: Found BIOS32 Service Directory header at 0xc00f6f40
bios32: Entry = 0xfd780 (c00fd780)  Rev = 0  Len = 1
pcibios: PCI BIOS entry at 0xfd780+0x11e
pnpbios: Found PnP BIOS data at 0xc00f6f90
pnpbios: Entry = f0000:953b  Rev = 1.0
Other BIOS signatures found:
wlan: <802.11 Link Layer>
netsmb_dev: loaded
null: <null device, zero device>
random: <entropy source>
mem: <memory & I/O>
npx0: [FAST]
npx0: <math processor> on motherboard
npx0: INT 16 interface
acpi0: <FUJ PAULING3> on motherboard
pci_open(1):	mode 1 addr port (0x0cf8) is 0x80003074
pci_open(1a):	mode1res=0x80000000 (0x80000000)
pci_cfgcheck:	device 0 [class=060000] [hdr=80] is there (id=03951279)
pcibios: BIOS version 2.10
Using $PIR table, 9 entries at 0xc00fdf30
PCI-Only Interrupts: none
Location  Bus Device Pin  Link  IRQs
embedded    0    2    A   0x59  3 4 5 7 10 11
embedded    0    4    A   0x08  3 4 5 7 9 10 14 15
embedded    0   12    A   0x01  3 4 5 7 9 10 14 15
embedded    0   16    A   0x02  3 4 5 7 9 10 14 15
embedded    0   18    A   0x05  3 4 5 7 9 10 14 15
embedded    0   18    B   0x06  3 4 5 7 9 10 14 15
embedded    0   19    A   0x03  3 4 5 7 9 10 14 15
embedded    0   20    A   0x04  3 4 5 7 9 10 14 15
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 6 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 7 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 7 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 6 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 15 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 6 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 6 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 6 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 16 func 0
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 12 func 0
acpi0: Power Button (fixed)
ACPI timer looks BAD  min = 2, max = 839, width = 837
ACPI timer looks BAD  min = 2, max = 6, width = 4
ACPI timer looks BAD  min = 2, max = 18, width = 16
ACPI timer looks GOOD min = 2, max = 4, width = 2
ACPI timer looks GOOD min = 2, max = 4, width = 2
ACPI timer looks GOOD min = 2, max = 4, width = 2
ACPI timer looks BAD  min = 2, max = 8, width = 6
ACPI timer looks GOOD min = 2, max = 4, width = 2
ACPI timer looks BAD  min = 2, max = 8, width = 6
ACPI timer looks GOOD min = 2, max = 4, width = 2
Timecounter "ACPI-safe" frequency 3579545 Hz quality 1000
acpi_bus_number: root bus has no _BBN, assuming 0
AcpiOsDerivePciId: bus 0 dev 0 func 0
acpi_timer0: <24-bit timer at 3.579545MHz> port 0xff08-0xff0b on acpi0
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
acpi_cpu0: <CPU> port 0x530-0x537 on acpi0
pcib0: <ACPI Host-PCI bridge> port 0xcf8-0xcff on acpi0
---- initial configuration ------------------------
\\_SB_.PCI0.EIO_.LNKU irq  11: [  3  4  5  7  9 10 11] low,level,sharable 0.2.0
\\_SB_.PCI0.EIO_.LNKH irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.4.0
\\_SB_.PCI0.EIO_.LNKA irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.9.0
\\_SB_.PCI0.EIO_.LNKB irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.9.1
\\_SB_.PCI0.EIO_.LNKC irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.9.2
\\_SB_.PCI0.EIO_.LNKA irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.12.0
\\_SB_.PCI0.EIO_.LNKC irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.19.0
\\_SB_.PCI0.EIO_.LNKD irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.20.0
\\_SB_.PCI0.EIO_.LNKB irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.16.0
\\_SB_.PCI0.EIO_.LNKE irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.18.0
\\_SB_.PCI0.EIO_.LNKF irq   0: [  3  4  5  7  9 10 11] low,level,sharable 0.18.1
---- before setting priority for links ------------
\\_SB_.PCI0.EIO_.LNKF:
	interrupts:	     3     4     5     7     9    10    11
	penalty:	  1110  1110   110  1110  1010   110   210
	references:	1
	priority:	0
---- before fixup boot-disabled links -------------
\\_SB_.PCI0.EIO_.LNKF:
	interrupts:	     3     4     5     7     9    10    11
	penalty:	  1110  1110   110  1110  1010   110   210
	references:	1
	priority:	681
---- after fixup boot-disabled links --------------
---- arbitrated configuration ---------------------
\\_SB_.PCI0.EIO_.LNKU irq  11: [  3  4  5  7  9 10 11] low,level,sharable 0.2.0
\\_SB_.PCI0.EIO_.LNKH irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.4.0
\\_SB_.PCI0.EIO_.LNKA irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.9.0
\\_SB_.PCI0.EIO_.LNKB irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.9.1
\\_SB_.PCI0.EIO_.LNKC irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.9.2
\\_SB_.PCI0.EIO_.LNKA irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.12.0
\\_SB_.PCI0.EIO_.LNKC irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.19.0
\\_SB_.PCI0.EIO_.LNKD irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.20.0
\\_SB_.PCI0.EIO_.LNKB irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.16.0
\\_SB_.PCI0.EIO_.LNKE irq   9: [  3  4  5  7  9 10 11] low,level,sharable 0.18.0
\\_SB_.PCI0.EIO_.LNKF irq  10: [  3  4  5  7  9 10 11] low,level,sharable 0.18.1
pci0: <ACPI PCI bus> on pcib0
pci0: physical bus=0
	map[10]: type 1, range 32, base e8000000, size 20, enabled
found->	vendor=0x1279, dev=0x0395, revid=0x03
	bus=0, slot=0, func=0
	class=06-00-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0006, statreg=0x0200, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
found->	vendor=0x1279, dev=0x0396, revid=0x00
	bus=0, slot=0, func=1
	class=05-00-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0000, statreg=0x0000, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
found->	vendor=0x1279, dev=0x0397, revid=0x00
	bus=0, slot=0, func=2
	class=05-00-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0000, statreg=0x0000, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	map[10]: type 1, range 32, base e8100000, size 12, enabled
pcib0: matched entry for 0.2.INTA (source \\_SB_.PCI0.EIO_.LNKU)
pcib0: slot 2 INTA is routed to irq 11
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=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x50 (20000 ns)
	intpin=a, irq=11
	powerspec 2  supports D0 D3  current D0
	map[10]: type 4, range 32, base 00001000, size  8, port disabled
	map[14]: type 1, range 32, base e8101000, size 12, memory disabled
pcib0: matched entry for 0.4.INTA (source \\_SB_.PCI0.EIO_.LNKH)
pcib0: slot 4 INTA is routed to irq 9
found->	vendor=0x10b9, dev=0x5451, revid=0x01
	bus=0, slot=4, func=0
	class=04-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x18 (6000 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D1 D2 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
found->	vendor=0x1033, dev=0x0035, revid=0x41
	bus=0, slot=9, func=0
	class=0c-03-10, hdrtype=0x00, mfdev=1
	cmdreg=0x0000, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x08 (240 ns), mingnt=0x01 (250 ns), maxlat=0x2a (10500 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
found->	vendor=0x1033, dev=0x0035, revid=0x41
	bus=0, slot=9, func=1
	class=0c-03-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x08 (240 ns), mingnt=0x01 (250 ns), maxlat=0x2a (10500 ns)
	intpin=b, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
found->	vendor=0x1033, dev=0x00e0, revid=0x02
	bus=0, slot=9, func=2
	class=0c-03-20, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x44 (2040 ns), mingnt=0x10 (4000 ns), maxlat=0x22 (8500 ns)
	intpin=c, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
pcib0: matched entry for 0.12.INTA (source \\_SB_.PCI0.EIO_.LNKA)
pcib0: slot 12 INTA is routed to irq 9
found->	vendor=0x104c, dev=0xac50, revid=0x01
	bus=0, slot=12, func=0
	class=06-07-00, hdrtype=0x02, mfdev=0
	cmdreg=0x0007, statreg=0x0210, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0xc0 (48000 ns), maxlat=0x03 (750 ns)
	intpin=a, irq=9
	powerspec 1  supports D0 D1 D2 D3  current D0
	map[20]: type 4, range 32, base 00001400, size  4, enabled
found->	vendor=0x10b9, dev=0x5229, revid=0xc3
	bus=0, slot=15, func=0
	class=01-01-fa, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x02 (500 ns), maxlat=0x04 (1000 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D3  current D0
	map[10]: type 4, range 32, base 00008000, size  8, port disabled
	map[14]: type 1, range 32, base e8102000, size  8, memory disabled
pcib0: matched entry for 0.16.INTA (source \\_SB_.PCI0.EIO_.LNKB)
pcib0: slot 16 INTA is routed to irq 9
found->	vendor=0x10ec, dev=0x8139, revid=0x10
	bus=0, slot=16, func=0
	class=02-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x20 (8000 ns), maxlat=0x40 (16000 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 3, range 32, base e8103000, size 12, memory disabled
pcib0: matched entry for 0.18.INTA (source \\_SB_.PCI0.EIO_.LNKE)
pcib0: slot 18 INTA is routed to irq 9
found->	vendor=0x1260, dev=0x3873, revid=0x01
	bus=0, slot=18, func=0
	class=02-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0010, statreg=0x0290, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base e8102800, size 11, memory disabled
	map[14]: type 1, range 32, base e8104000, size 14, enabled
pcib0: matched entry for 0.19.INTA (source \\_SB_.PCI0.EIO_.LNKC)
pcib0: slot 19 INTA is routed to irq 9
found->	vendor=0x104c, dev=0x8026, revid=0x00
	bus=0, slot=19, func=0
	class=0c-00-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0010, statreg=0x0210, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x04 (1000 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 3, range 32, base f0000000, size 27, enabled
	map[14]: type 4, range 32, base 00001800, size  8, enabled
	map[18]: type 1, range 32, base e8110000, size 16, enabled
pcib0: matched entry for 0.20.INTA (source \\_SB_.PCI0.EIO_.LNKD)
pcib0: slot 20 INTA is routed to irq 9
found->	vendor=0x1002, dev=0x4c59, revid=0x00
	bus=0, slot=20, func=0
	class=03-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0083, statreg=0x0290, cachelnsz=8 (dwords)
	lattimer=0x42 (1980 ns), mingnt=0x08 (2000 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D1 D2 D3  current D0
pci0: <memory, RAM> at device 0.1 (no driver attached)
pci0: <memory, RAM> at device 0.2 (no driver attached)
ohci0: <AcerLabs M5237 (Aladdin-V) USB controller> mem 0xe8100000-0xe8100fff irq 11 at device 2.0 on pci0
usb0: OHCI version 1.0, legacy support
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: 3 ports with 3 removable, self powered
pcm0: <Acer Labs M5451> port 0x1000-0x10ff mem 0xe8101000-0xe8101fff irq 9 at device 4.0 on pci0
pcm0: <Unknown AC97 Codec (id = 0x83847666)>
pcm0: Codec features headphone, 20 bit DAC, 18 bit ADC, 5 bit master volume, SigmaTel 3D Enhancement
pcm0: Primary codec extended features variable rate PCM, reserved 1, AMAP, reserved 4
pcm0: sndbuf_setmap 1e4b3000, 1000; 0xc429f000 -> 1e4b3000
pcm0: sndbuf_setmap 1e411000, 1000; 0xc429d000 -> 1e411000
pcm0: sndbuf_setmap 1e40f000, 1000; 0xc429b000 -> 1e40f000
pcm0: sndbuf_setmap 1e40d000, 1000; 0xc4299000 -> 1e40d000
pcm0: sndbuf_setmap 243000, 1000; 0xc42af000 -> 243000
pci0: <bridge, PCI-unknown> at device 6.0 (no driver attached)
isab0: <PCI-ISA bridge> at device 7.0 on pci0
isa0: <ISA bus> on isab0
ohci1: <NEC uPD 9210 USB controller> at device 9.0 on pci0
ohci1: Could not map memory
device_probe_and_attach: ohci1 attach returned 6
ohci1: <NEC uPD 9210 USB controller> at device 9.1 on pci0
ohci1: Could not map memory
device_probe_and_attach: ohci1 attach returned 6
ehci0: <NEC uPD 720100 USB 2.0 controller> at device 9.2 on pci0
ehci0: Could not map memory
device_probe_and_attach: ehci0 attach returned 6
cbb0: <TI1410 PCI-CardBus Bridge> irq 9 at device 12.0 on pci0
cardbus0: <CardBus bus> on cbb0
pccard0: <16-bit PCCard bus> on cbb0
cbb0: [MPSAFE]
cbb0: PCI Configuration space:
  0x00: 0xac50104c 0x02100007 0x06070001 0x00024008 
  0x10: 0x88000000 0x020000a0 0x20000000 0xfffff000 
  0x20: 0x00000000 0xfffff000 0x00000000 0xfffffffc 
  0x30: 0x00000000 0xfffffffc 0x00000000 0x07400109 
  0x40: 0x10c610cf 0x00000001 0x00000000 0x00000000 
  0x50: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x60: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x70: 0x00000000 0x00000000 0x00000000 0x00000000 
  0x80: 0x00649060 0x00000000 0x00000000 0x00c61d22 
  0x90: 0x414602c0 0x00000000 0x00000000 0x00000000 
  0xa0: 0xfe110001 0x00c00000 0x00000000 0x00000007 
  0xb0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xc0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xd0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xe0: 0x00000000 0x00000000 0x00000000 0x00000000 
  0xf0: 0x00000000 0x00000000 0x00000000 0x00000000 
atapci0: <AcerLabs Aladdin UDMA66 controller> port 0x1400-0x140f at device 15.0 on pci0
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 mask=03 stat0=50 stat1=00 devices=0x1<ATA_MASTER>
ata0: at 0x1f0 irq 14 on atapci0
ata0: [MPSAFE]
ata1: at 0x170 irq 15 on atapci0
ata1: [MPSAFE]
rl0: <RealTek 8139 10/100BaseTX> port 0x8000-0x80ff mem 0xe8102000-0xe81020ff irq 9 at device 16.0 on pci0
rl0: Ethernet address: 00:0b:5d:0d:19:db
miibus0: <MII bus> on rl0
rlphy0: <RealTek internal media interface> on miibus0
rlphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
rl0: bpf attached
wi0: <Intersil Prism2.5> mem 0xe8103000-0xe8103fff irq 9 at device 18.0 on pci0
wi0: 802.11 address: 00:e0:00:d1:96:c5
wi0: using RF:PRISM2.5 MAC:ISL3874A(Mini-PCI)
wi0: Intersil Firmware: Primary (1.1.0), Station (1.4.1)
wi0: bpf attached
wi0: bpf attached
wi0: 11b rates: 1Mbps 2Mbps 5.5Mbps 11Mbps
wi0: bpf attached
fwohci0: vendor=104c, dev=8026
fwohci0: <1394 Open Host Controller Interface> mem 0xe8104000-0xe8107fff,0xe8102800-0xe8102fff irq 9 at device 19.0 on pci0
fwohci0: latency timer 64 -> 64.
fwohci0: cache size 8 -> 8.
fwohci0: OHCI version 1.10 (ROM=0)
fwohci0: No. of Isochronous channel is 4.
fwohci0: EUI64 00:00:0e:10:00:f0:5a:ca
fwohci0: resetting OHCI...done (loop=0)
fwohci0: fwphy_rddata: 0x2 loop=0, retry=0
fwohci0: fwphy_rddata: 0x3 loop=0, retry=0
fwohci0: Phy 1394a available S400, 1 ports.
fwohci0: fwphy_rddata: 0x5 loop=0, retry=0
fwohci0: Enable 1394a Enhancements
fwohci0: fwphy_rddata: 0x5 loop=0, retry=0
fwohci0: fwphy_rddata: 0x2 loop=0, retry=0
fwohci0: fwphy_rddata: 0x4 loop=0, retry=0
fwohci0: fwphy_rddata: 0x4 loop=0, retry=0
fwohci0: fwphy_rddata: 0x4 loop=0, retry=0
fwohci0: Link S400, max_rec 2048 bytes.
fwohci0: BUS_OPT 0xa002 -> 0xf800a002
fwohci0: fwohci_set_intr: 1
firewire0: <IEEE1394(FireWire) bus> on fwohci0
fwohci0: Initiate bus reset
fwohci0: fwphy_rddata: 0x1 loop=0, retry=0
fwohci0: fwphy_rddata: 0x1 loop=0, retry=0
fwohci0: BUS reset
fwohci0: node_id=0xc800ffc0, gen=1, CYCLEMASTER mode
firewire0: 1 nodes, maxhop <= 0, cable IRM = 0 (me)
fwohci0: fw_set_bus_manager: 0->0 (loop=0)
firewire0: bus manager 0 (me)
send phy_config root_node=-1 gap_count=5
fwohci0: maxdesc: 2
fwohci0: start AT DMA status=0
drm0: <ATI Radeon LY Mobility M6> port 0x1800-0x18ff mem 0xe8110000-0xe811ffff,0xf0000000-0xf7ffffff irq 9 at device 20.0 on pci0
info: [drm] Initialized radeon 1.10.0 20020828 on minor 0
acpi_button0: <Power Button> on acpi0
acpi_acad0: <AC Adapter> on acpi0
acpi_cmbat0: <Control Method Battery> on acpi0
acpi_cmbat1: <Control Method Battery> on acpi0
acpi_lid0: <Control Method Lid Switch> on acpi0
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
psmcpnp0 irq 12 on acpi0
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> flags 0x1 irq 1 on atkbdc0
atkbd: the current kbd controller command byte 0047
atkbd: keyboard ID 0x54ab (2)
kbd0 at atkbd0
kbd0: atkbd0, AT 101/102 (2), config:0x1, flags:0x3d0000
psm0: current command byte:0047
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: model Generic PS/2 mouse, device ID 0-00, 2 buttons
psm0: config:00000000, flags:00000000, packet size:3
psm0: syncmask:c0, syncbits:00
acpi_ec0: <Embedded Controller: GPE 0> port 0x66,0x62 on acpi0
Fujitsu P-SERIES FUJ02B1 Driver Loaded.
acpi_fjex0: <Fujitsu Function Buttons> on acpi0
unknown: not probed (disabled)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
unknown: not probed (disabled)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
unknown: not probed (disabled)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
unknown: not probed (disabled)
ata: ata0 already exists; skipping it
ata: ata1 already exists; skipping it
atkbdc: atkbdc0 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: <Option ROM> at iomem 0xc0000-0xcdfff 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)
fdc0: ready for input in output
fdc0: cmd 3 failed at out byte 1 of 3
fdc0 failed to probe at port 0x3f7,0x3f0-0x3f5 irq 6 drq 2 on isa0
fe0: not probed (disabled)
ie0: not probed (disabled)
le0: not probed (disabled)
lnc0: not probed (disabled)
pcic0 failed to probe at port 0x3e0 iomem 0xd0000 on isa0
pcic1: not probed (disabled)
ppc0 failed to probe at irq 7 on isa0
sc0: <System console> at flags 0x100 on isa0
sc0: VGA <16 virtual consoles, flags=0x300>
sc0: fb0, kbd0, terminal emulator: sc (syscons terminal)
sio0 failed to probe at port 0x3f8 irq 4 flags 0x10 on isa0
sio1 failed to probe at port 0x2f8 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:0x7007f
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 7e 4f 4f 82 55 03 
b4 1f 00 4f 0d 0e 00 00 06 40 92 88 8f 28 1f 8f 
b5 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 7e 4f 4f 82 55 03 
b4 1f 00 4f 0d 0e 00 00 06 40 92 88 8f 28 1f 8f 
b5 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
linprocfs registered
Timecounter "TSC" frequency 925439631 Hz quality 800
Timecounters tick every 10.000 msec
ipfw2 initialized, divert enabled, rule-based forwarding enabled, default to deny, logging limited to 100 packets/entry by default
Linux ELF exec handler installed
lo0: bpf attached
Current DB 0
ch = 0
 Current OP   KEY INT BR   len     Addr   Depend Stat: Cnt
1e4bd000 OUTL ST2 ALL ALL    12 00000000 1e4bd080 8411:0014 RUN,ACTIVE, ack complete(11)
0x000000e0 0x00450000 0xffbaffff 0x00000000
acpi_cpu0: set speed to 100.0%
acpi_cpu: throttling enabled, 8 steps (100% to 12.5%), currently 100.0%
acpi_acad0: acline initialization start
system power profile changed to 'economy'
acpi_acad0: Off Line
acpi_cmbat0: battery initialization start
acpi_cmbat0: battery initialization done, tried 1 times
acpi_cmbat1: battery initialization start
ata0-master: pio=0x0c wdma=0x22 udma=0x45 cable=80pin
ata0-master: setting PIO4 on AcerLabs Aladdin chip
ata0-master: setting UDMA66 on AcerLabs Aladdin chip
GEOM: create disk ad0 dp=0xc43e8c60
ad0: <TOSHIBA MK4021GAS/GA225F> ATA-5 disk at ata0-master
ad0: 38154MB (78140160 sectors), 77520 C, 16 H, 63 S, 512 B
ad0: 1 secs/int, 1 depth queue, UDMA66
GEOM: new disk ad0
[0] f:80 typ:165 s(CHS):0/1/1 e(CHS):1023/254/63 s:63 l:78140097
[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:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s1, start 32256 length 40007729664 end 40007761919
GEOM: Configure ad0s1a, start 0 length 536870912 end 536870911
GEOM: Configure ad0s1b, start 38654705664 length 1353024000 end 40007729663
GEOM: Configure ad0s1c, start 0 length 40007729664 end 40007729663
GEOM: Configure ad0s1d, start 536870912 length 268435456 end 805306367
GEOM: Configure ad0s1e, start 805306368 length 268435456 end 1073741823
GEOM: Configure ad0s1f, start 1073741824 length 6442450944 end 7516192767
GEOM: Configure ad0s1g, start 7516192768 length 31138512896 end 38654705663
bus_explore done
Mounting root from ufs:/dev/ad0s1a
start_init: trying /sbin/init
acpi_acad0: acline initialization done, tried 7 times
acpi_cmbat1: battery initialization failed, giving up



acpidump -d
-------------------------------------------------------------------

/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20031203
 *
 * Disassembly of /tmp/acpidump.fUwfjp, Fri Jan 16 12:40:35 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "FUJ   ", "PAULING3", 17170432)
{
    Name (BIDT, Buffer (0x10)
    {
        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03
    })
    Name (BDCT, Package (0x04)
    {
        0x076C, 
        0x0ED8, 
        0x0D48, 
        0x0D48
    })
    Name (BMNT, Package (0x04)
    {
        "CP112050-XX / CP112051-XX", 
        "CP112055-XX / CP112056-XX", 
        "CP112045-XX / CP112046-XX", 
        "CP144820-XX / CP144821-XX"
    })
    Name (RGSI, 0x1D)
    Name (BYIS, 0xFF)
    Name (BYDF, Zero)
    Name (BYIF, Ones)
    Name (BYRF, Zero)
    Name (SCEF, Zero)
    Name (ANTS, Zero)
    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x0000FF10, 0x06) {}
    }

    Name (TOSS, Zero)
    Method (TOOS, 0, NotSerialized)
    {
        If (LEqual (TOSS, Zero))
        {
            If (CondRefOf (\_OSI, Local0))
            {
                If (\_OSI ("Windows 2000"))
                {
                    Store (0x03, TOSS)
                }

                If (\_OSI ("Windows 2001"))
                {
                    Store (0x04, TOSS)
                }
            }
            Else
            {
                If (LEqual (SizeOf (_OS), 0x11))
                {
                    Store (0x01, TOSS)
                }

                If (LEqual (SizeOf (_OS), 0x27))
                {
                    Store (0x02, TOSS)
                }

                If (LEqual (SizeOf (_OS), 0x14))
                {
                    Store (0x03, TOSS)
                }
            }
        }

        Return (TOSS)
    }

    Scope (_SB)
    {
        OperationRegion (PSIO, SystemIO, 0x0000FE00, 0x02)
        OperationRegion (PSBF, SystemMemory, 0x1EFEFF2C, 0x90)
        OperationRegion (OEMT, SystemMemory, 0x1EFEFEDC, 0x0020)
        OperationRegion (BLCT, SystemMemory, 0x1EFEFEFC, 0x0030)
        OperationRegion (VDEX, SystemMemory, 0x1EFEFECC, 0x0010)
        OperationRegion (PO80, SystemIO, 0x80, 0x01)
        Scope (\)
        {
            Field (\_SB.PSIO, ByteAcc, NoLock, Preserve)
            {
                SSMI,   8
            }

            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
            {
                CMD,    8, 
                DVID,   32, 
                DATA,   32
            }

            Field (\_SB.OEMT, ByteAcc, NoLock, Preserve)
            {
                IRQF,   16, 
                SPAF,   2, 
                SPBF,   2, 
                PPF,    3, 
                Offset (0x03), 
                SIDF,   2, 
                FDCF,   1, 
                PS2F,   1, 
                IMTF,   1, 
                Offset (0x04), 
                WAPB,   1, 
                BWEN,   1, 
                BLEN,   1, 
                BLEX,   1
            }

            Field (\_SB.BLCT, ByteAcc, NoLock, Preserve)
            {
                BLLM,   8, 
                BHKF,   1, 
                    ,   1, 
                VHKF,   1, 
                MHKF,   1, 
                Offset (0x02), 
                BLLT,   64, 
                VOLM,   8, 
                VOLT,   136
            }

            Field (\_SB.BLCT, ByteAcc, NoLock, Preserve)
            {
                Offset (0x01), 
                AHKF,   8
            }

            Field (\_SB.VDEX, ByteAcc, NoLock, Preserve)
            {
                CLCD,   1, 
                CCRT,   1, 
                CTV,    1, 
                ALCD,   1, 
                ACRT,   1, 
                ATV,    1, 
                Offset (0x01), 
                PNLT,   8
            }

            Field (\_SB.PO80, ByteAcc, NoLock, Preserve)
            {
                IO80,   8
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_PRW, Package (0x02)
            {
                0x09, 
                0x04
            })
            Name (_PRT, Package (0x0B)
            {
                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKU, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKH, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKA, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x02, 
                    \_SB.PCI0.EIO.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0013FFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0014FFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKD, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x00, 
                    \_SB.PCI0.EIO.LNKE, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0012FFFF, 
                    0x01, 
                    \_SB.PCI0.EIO.LNKF, 
                    0x00
                }
            })
            OperationRegion (REGS, PCI_Config, 0x48, 0x18)
            Field (REGS, DWordAcc, NoLock, Preserve)
            {
                Offset (0x02), 
                TOMX,   16
            }

            Field (REGS, DWordAcc, NoLock, Preserve)
            {
                Offset (0x12), 
                PA14,   32
            }

            Field (REGS, DWordAcc, NoLock, Preserve)
            {
                Offset (0x14), 
                PA36,   32
            }

            Name (RSRC, Buffer (0x8E)
            {
                0x88, 0x0E, 0x00, 0x02, 0x0C, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 
                0x00, 0x47, 0x01, 0xF8, 0x0C, 0xF8, 0x0C, 0x01, 
                0x08, 0x88, 0x0E, 0x00, 0x01, 0x0C, 0x03, 0x00, 
                0x00, 0x00, 0x00, 0xF7, 0x0C, 0x00, 0x00, 0xF8, 
                0x0C, 0x00, 0x88, 0x0E, 0x00, 0x01, 0x0C, 0x03, 
                0x00, 0x00, 0x00, 0x0D, 0xFF, 0xFF, 0x00, 0x00, 
                0x00, 0xF3, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0C, 
                0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 
                0x00, 0xFF, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x87, 0x18, 
                0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xFF, 0x0E, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 
                0x00, 0x87, 0x18, 0x00, 0x00, 0x0C, 0x03, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 
                0xFF, 0xEF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x79, 0x00
            })
            Method (_CRS, 0, Serialized)
            {
                CreateDWordField (RSRC, 0x7B, BTMN)
                CreateDWordField (RSRC, 0x7F, BTMX)
                CreateDWordField (RSRC, 0x87, BTLN)
                ShiftLeft (TOMX, 0x10, BTMN)
                Add (BTMN, 0x00100000, BTMN)
                Add (Subtract (BTMX, BTMN), 0x01, BTLN)
                CreateDWordField (RSRC, 0x60, UMMN)
                CreateDWordField (RSRC, 0x64, UMMX)
                CreateDWordField (RSRC, 0x6C, UMLN)
                Store (0x000C0000, Local0)
                Store (PA14, Local1)
                While (And (Local1, 0x03))
                {
                    Add (Local0, 0x4000, Local0)
                    ShiftRight (Local1, 0x04, Local1)
                }

                Store (Local0, UMMN)
                Store (0x000EFFFF, Local0)
                Store (PA36, Local1)
                While (And (Local1, 0x30000000))
                {
                    Subtract (Local0, 0x4000, Local0)
                    ShiftLeft (Local1, 0x04, Local1)
                }

                Store (Local0, UMMX)
                Add (Subtract (UMMX, UMMN), 0x01, UMLN)
                Return (RSRC)
            }

            OperationRegion (LRCR, PCI_Config, 0xA8, 0x04)
            Scope (\)
            {
                Field (\_SB.PCI0.LRCR, ByteAcc, NoLock, Preserve)
                {
                    LRON,   1, 
                    LRRV,   3, 
                    LREN,   1
                }
            }

            Device (PWR)
            {
                Name (_ADR, 0x00060000)
                OperationRegion (CRSM, PCI_Config, 0x84, 0x0C)
                OperationRegion (APMA, PCI_Config, 0x55, 0x01)
                OperationRegion (HDBT, PCI_Config, 0x5D, 0x01)
                OperationRegion (SME1, PCI_Config, 0x40, 0x02)
                OperationRegion (SMS1, PCI_Config, 0x42, 0x02)
                OperationRegion (DVMT, PCI_Config, 0x60, 0x02)
                OperationRegion (CTHM, PCI_Config, 0x82, 0x01)
                OperationRegion (CGPI, PCI_Config, 0x94, 0x2C)
                Scope (\)
                {
                    Field (\_SB.PCI0.PWR.CRSM, ByteAcc, NoLock, Preserve)
                    {
                            ,   9, 
                        EFE2,   1, 
                        ERE2,   1, 
                            ,   2, 
                        EFE3,   1, 
                        ERE3,   1, 
                        Offset (0x08), 
                            ,   1, 
                        EER2,   2
                    }

                    Field (\_SB.PCI0.PWR.SME1, ByteAcc, NoLock, Preserve)
                    {
                            ,   4, 
                        APAE,   1, 
                        Offset (0x01), 
                            ,   3, 
                        HBTE,   1
                    }

                    Field (\_SB.PCI0.PWR.SMS1, ByteAcc, NoLock, WriteAsZeros)
                    {
                            ,   4, 
                        APAS,   1, 
                        Offset (0x01), 
                            ,   3, 
                        HBTS,   1
                    }

                    Field (\_SB.PCI0.PWR.APMA, ByteAcc, NoLock, Preserve)
                    {
                        APAC,   8
                    }

                    Field (\_SB.PCI0.PWR.HDBT, ByteAcc, NoLock, Preserve)
                    {
                        HBTC,   8
                    }

                    Field (\_SB.PCI0.PWR.DVMT, ByteAcc, NoLock, Preserve)
                    {
                            ,   2, 
                        ESHE,   2
                    }

                    Field (\_SB.PCI0.PWR.CTHM, ByteAcc, NoLock, Preserve)
                    {
                            ,   1, 
                        THLE,   1, 
                        THHE,   1, 
                        THEL,   1, 
                        THST,   1
                    }

                    Field (\_SB.PCI0.PWR.CGPI, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x03), 
                            ,   2, 
                        BYS1,   1, 
                        BYS2,   1, 
                        Offset (0x09), 
                            ,   2, 
                        BYPW,   1, 
                        Offset (0x21), 
                        BYI1,   3, 
                        Offset (0x22), 
                            ,   1, 
                        BYI2,   1
                    }
                }

                Method (_INI, 0, NotSerialized)
                {
                    Store (One, EFE2)
                    Store (One, ERE2)
                    Store (0x03, EER2)
                }
            }

            Device (EIO)
            {
                Name (_ADR, 0x00070000)
                OperationRegion (PIRQ, PCI_Config, 0x48, 0x04)
                OperationRegion (PIR2, PCI_Config, 0x74, 0x01)
                OperationRegion (FJIO, SystemIO, 0xFD60, 0x06)
                Scope (\)
                {
                    Field (\_SB.PCI0.EIO.FJIO, ByteAcc, NoLock, Preserve)
                    {
                        JIDC,   8, 
                        JDTC,   8, 
                        JIDB,   8, 
                        JDTB,   8, 
                        JIDA,   8, 
                        JDTA,   8
                    }

                    IndexField (JIDA, JDTA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x09), 
                        RI0M,   1, 
                        RI1M,   1, 
                        RI2M,   1, 
                        RI3M,   1, 
                        RI0,    1, 
                        RI1,    1, 
                        RI2,    1, 
                        RI3,    1, 
                            ,   2, 
                        CVCL,   1, 
                            ,   3, 
                        BLCT,   2, 
                        Offset (0x20), 
                        G5P0,   8, 
                        G5C0,   8, 
                        G3P0,   8, 
                        G3C0,   8, 
                        Offset (0x40), 
                        SSF0,   8, 
                        SSF1,   8, 
                        SSM0,   8, 
                        SSM1,   8, 
                        SSI0,   8, 
                        SSTM,   8, 
                        SSF2,   8, 
                        SSM2,   8, 
                        SSI1,   8, 
                        Offset (0x52), 
                        G3P1,   8, 
                        G3C1,   8, 
                        G3P2,   8, 
                        G3C2,   8, 
                        QSWC,   8, 
                        Offset (0x60), 
                        SSS0,   8, 
                        SSS1,   8, 
                        Offset (0x71), 
                        RI4M,   1, 
                            ,   3, 
                        RI4,    1
                    }

                    IndexField (JIDB, JDTB, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x29), 
                        BRCL,   8, 
                        LCDB,   8, 
                        Offset (0x30), 
                        LCDC,   8, 
                        AMPV,   6
                    }

                    IndexField (JIDC, JDTC, ByteAcc, NoLock, Preserve)
                    {
                        TASF,   1, 
                        TBSF,   1, 
                        Offset (0x02), 
                            ,   4, 
                        VSTB,   1, 
                        Offset (0x05), 
                            ,   6, 
                        ACPW,   1, 
                        Offset (0x0A), 
                        B1P,    1, 
                        B2P,    1, 
                        B1C,    1, 
                        B2C,    1, 
                        B1ER,   1, 
                        B2ER,   1, 
                        Offset (0x0B), 
                        B1CP,   8, 
                        B2CP,   8, 
                        Offset (0x0E), 
                        B1VH,   8, 
                        B1VL,   8, 
                        B2VH,   8, 
                        B2VL,   8, 
                        Offset (0x14), 
                        B1CH,   8, 
                        B1CL,   8, 
                        B2CH,   8, 
                        B2CL,   8, 
                        Offset (0x1A), 
                        B1LH,   8, 
                        B1LL,   8, 
                        B2LH,   8, 
                        B2LL,   8, 
                        B2ID,   4, 
                        B1ID,   4, 
                        Offset (0x20), 
                        BCTL,   8, 
                        Offset (0x23), 
                        TAF,    1, 
                        TASM,   1, 
                            ,   2, 
                        TBF,    1, 
                        TBSM,   1, 
                        Offset (0x24), 
                        TIMA,   8, 
                        TIMB,   8, 
                        Offset (0x28), 
                        CDLP,   8, 
                        HDLP,   8, 
                        FDLP,   8
                    }

                    IndexField (JIDC, JDTC, ByteAcc, NoLock, Preserve)
                    {
                        STAE,   2
                    }
                }

                Scope (\)
                {
                    IndexField (JIDA, JDTA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x52), 
                        AMUT,   1
                    }
                }

                Method (_INI, 0, NotSerialized)
                {
                    Store (Zero, RI0M)
                    And (SSM2, 0xF7, SSM2)
                    Store (Zero, TASM)
                    Store (Zero, TBSM)
                }

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

                    Name (_CRS, Buffer (0x7A)
                    {
                        0x47, 0x01, 0x72, 0x00, 0x72, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x80, 0x00, 0x80, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0x92, 0x00, 0x92, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0xB0, 0x00, 0xB0, 0x00, 0x01, 0x04, 
                        0x47, 0x01, 0xEA, 0x00, 0xEA, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0x0B, 0x04, 0x0B, 0x04, 0x01, 0x01, 
                        0x47, 0x01, 0x80, 0x04, 0x80, 0x04, 0x01, 0x10, 
                        0x47, 0x01, 0xD0, 0x04, 0xD0, 0x04, 0x01, 0x02, 
                        0x47, 0x01, 0xD6, 0x04, 0xD6, 0x04, 0x01, 0x01, 
                        0x47, 0x01, 0x00, 0xF8, 0x00, 0xF8, 0x01, 0x80, 
                        0x47, 0x01, 0x80, 0xF8, 0x80, 0xF8, 0x01, 0x80, 
                        0x47, 0x01, 0x60, 0xFD, 0x60, 0xFD, 0x01, 0x08, 
                        0x47, 0x01, 0x00, 0xFE, 0x00, 0xFE, 0x01, 0x01, 
                        0x47, 0x01, 0x00, 0xFF, 0x00, 0xFF, 0x01, 0x40, 
                        0x47, 0x01, 0x80, 0xFF, 0x80, 0xFF, 0x01, 0x20, 
                        0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x1D)
                    {
                        0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 
                        0x47, 0x01, 0x81, 0x00, 0x81, 0x00, 0x01, 0x0F, 
                        0x47, 0x01, 0xC0, 0x00, 0xC0, 0x00, 0x01, 0x20, 
                        0x2A, 0x10, 0x02, 0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x15)
                    {
                        0x47, 0x01, 0x20, 0x00, 0x20, 0x00, 0x01, 0x02, 
                        0x47, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0x01, 0x02, 
                        0x22, 0x04, 0x00, 0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x01, 0x0F, 
                        0x22, 0x00, 0x20, 0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0x40, 0x00, 0x40, 0x00, 0x01, 0x04, 
                        0x22, 0x01, 0x00, 0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0x70, 0x00, 0x70, 0x00, 0x01, 0x02, 
                        0x22, 0x00, 0x01, 0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x0A)
                    {
                        0x47, 0x01, 0x61, 0x00, 0x61, 0x00, 0x01, 0x01, 
                        0x79, 0x00
                    })
                }

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

                    Name (_CRS, Buffer (0x05)
                    {
                        0x22, 0x00, 0x10, 0x79, 0x00
                    })
                }

                Device (KBC)
                {
                    Name (R101, 0x0303D041)
                    Name (R106, 0x2003D041)
                    Method (_HID, 0, NotSerialized)
                    {
                        If (SIDF)
                        {
                            Return (R101)
                        }
                        Else
                        {
                            Return (R106)
                        }
                    }

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

                    Name (_CRS, Buffer (0x15)
                    {
                        0x47, 0x01, 0x60, 0x00, 0x60, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0x64, 0x00, 0x64, 0x00, 0x01, 0x01, 
                        0x22, 0x02, 0x00, 0x79, 0x00
                    })
                }

                Device (EC)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, Buffer (0x12)
                    {
                        0x47, 0x01, 0x62, 0x00, 0x62, 0x00, 0x01, 0x01, 
                        0x47, 0x01, 0x66, 0x00, 0x66, 0x00, 0x01, 0x01, 
                        0x79, 0x00
                    })
                    Name (_GPE, 0x00)
                    Scope (\)
                    {
                        Name (ECOK, Zero)
                    }

                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECOK)
                        }
                    }

                    OperationRegion (SMB, EmbeddedControl, 0x00, 0x40)
                    Scope (\)
                    {
                        Field (\_SB.PCI0.EIO.EC.SMB, ByteAcc, Lock, Preserve)
                        {
                            Offset (0x04), 
                            ECCM,   8, 
                            ECD1,   8, 
                            ECD2,   8, 
                            ECD3,   8
                        }
                    }
                }

                Device (FJEX)
                {
                    Name (_HID, "FUJ02B1")
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (RBLL, 0, NotSerialized)
                    {
                        Return (BLLM)
                    }

                    Scope (\)
                    {
                        Name (LBLL, 0x00)
                        Name (LLCD, Ones)
                    }

                    Method (GBLL, 0, NotSerialized)
                    {
                        Store (LBLL, Local2)
                        Store (LCDB, Local1)
                        If (LNot (LEqual (LLCD, Local1)))
                        {
                            Store (Local1, LLCD)
                            Name (BBCT, Buffer (BLLM) {})
                            Store (BLLT, BBCT)
                            Store (BLLM, Local0)
                            While (Local0)
                            {
                                Decrement (Local0)
                                If (LEqual (GBUF (BBCT, Local0), Local1))
                                {
                                    Store (Local0, Local2)
                                    Store (Local0, LBLL)
                                    Store (Zero, Local0)
                                }
                            }
                        }

                        If (BHKF)
                        {
                            Store (Zero, BHKF)
                            Or (Local2, 0x80000000, Local2)
                        }

                        Return (Local2)
                    }

                    Method (SBLL, 1, NotSerialized)
                    {
                        If (LLess (Arg0, BLLM))
                        {
                            Name (BBCT, Buffer (BLLM) {})
                            Store (BLLT, BBCT)
                            CreateByteField (BBCT, Arg0, BLL0)
                            Store (BLL0, LCDB)
                            Store (Arg0, DVID)
                            Store (0x82, CMD)
                            Store (Zero, SSMI)
                        }
                    }

                    Method (GBUF, 2, NotSerialized)
                    {
                        CreateByteField (Arg0, Arg1, BLL0)
                        Return (BLL0)
                    }

                    Method (RVOL, 0, NotSerialized)
                    {
                        Return (VOLM)
                    }

                    Scope (\)
                    {
                        Name (VOLL, 0x00)
                        Name (LVOL, Ones)
                    }

                    Method (GVOL, 0, NotSerialized)
                    {
                        Store (VOLL, Local2)
                        Store (AMPV, Local1)
                        If (LNot (LEqual (LVOL, Local1)))
                        {
                            Store (Local1, LVOL)
                            Name (VLCT, Buffer (VOLM) {})
                            Store (VOLT, VLCT)
                            Store (VOLM, Local0)
                            While (Local0)
                            {
                                Decrement (Local0)
                                If (LEqual (GBUF (VLCT, Local0), Local1))
                                {
                                    Store (Local0, Local2)
                                    Store (Local0, VOLL)
                                    Store (Zero, Local0)
                                }
                            }
                        }

                        If (LEqual (AMUT, 0x01))
                        {
                            Or (Local2, 0x40000000, Local2)
                        }

                        If (VHKF)
                        {
                            Store (Zero, VHKF)
                            Or (Local2, 0x80000000, Local2)
                        }

                        Return (Local2)
                    }

                    Method (SVOL, 1, NotSerialized)
                    {
                        If (And (Arg0, 0x40000000))
                        {
                            Store (0x01, AMUT)
                        }
                        Else
                        {
                            Store (0x00, AMUT)
                        }

                        And (Arg0, 0x3FFFFFFF, Local0)
                        If (LLess (Local0, VOLM))
                        {
                            Name (VLCT, Buffer (VOLM) {})
                            Store (VOLT, VLCT)
                            CreateByteField (VLCT, Local0, VOL0)
                            Store (VOL0, AMPV)
                            Store (Local0, DVID)
                            Store (0x90, CMD)
                            Store (Zero, SSMI)
                        }
                    }

                    Method (GMOU, 0, NotSerialized)
                    {
                        Store (0x02, DVID)
                        Store (0x91, CMD)
                        Store (Zero, SSMI)
                        Store (DVID, Local0)
                        If (MHKF)
                        {
                            Store (Zero, MHKF)
                            Or (Local0, 0x80000000, Local0)
                        }

                        Return (Local0)
                    }

                    Method (SMOU, 1, NotSerialized)
                    {
                        If (LNot (LGreater (Arg0, One)))
                        {
                            Store (Arg0, DVID)
                            Store (0x91, CMD)
                            Store (Zero, SSMI)
                        }
                    }

                    Method (GHKS, 0, NotSerialized)
                    {
                        Return (AHKF)
                    }

                    Method (GSIF, 0, NotSerialized)
                    {
                        If (IMTF)
                        {
                            Or (RGSI, 0x08, RGSI)
                        }
                        Else
                        {
                            And (RGSI, 0xFFFFFFF7, RGSI)
                        }

                        Return (RGSI)
                    }
                }

                Scope (\)
                {
                    IndexField (JIDA, JDTA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x20), 
                            ,   6, 
                        WLBT,   1, 
                        Offset (0x22), 
                            ,   6, 
                        WLRF,   1, 
                        Offset (0x23), 
                            ,   6, 
                        WANT,   1, 
                        Offset (0x44), 
                            ,   2, 
                        BLST,   1, 
                        Offset (0x52), 
                            ,   1, 
                        BRST,   1, 
                            ,   1, 
                        BLON,   1
                    }
                }

                Device (CMBT)
                {
                    Name (_HID, "FUJ02E1")
                    Method (_INI, 0, NotSerialized)
                    {
                        Store (0x00, DVID)
                        Store (0x94, CMD)
                        Store (Zero, SSMI)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNot (BLEX))
                        {
                            If (BLEN)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (INFO, 0, NotSerialized)
                    {
                        Store (Zero, Local0)
                        Or (Local0, 0x01, Local0)
                        Or (Local0, 0x02, Local0)
                        Or (Local0, 0x04, Local0)
                        Or (Local0, 0x10, Local0)
                        Return (Local0)
                    }

                    Method (STAT, 0, NotSerialized)
                    {
                        Store (Zero, Local0)
                        If (LEqual (BRST, 0x01))
                        {
                            Or (Local0, 0x01, Local0)
                        }

                        If (LEqual (BLON, 0x01))
                        {
                            Or (Local0, 0x02, Local0)
                        }
                        Else
                        {
                            If (LEqual (BLST, 0x00))
                            {
                                Or (Local0, 0x02, Local0)
                            }
                        }

                        If (LEqual (BWEN, 0x01))
                        {
                            Or (Local0, 0x04, Local0)
                        }

                        If (LEqual (WLBT, 0x01))
                        {
                            If (LEqual (WANT, 0x00))
                            {
                                If (LEqual (WLRF, 0x01))
                                {
                                    Or (Local0, 0x08, Local0)
                                }
                            }
                        }
                        Else
                        {
                            Or (Local0, 0x10, Local0)
                        }

                        Return (Local0)
                    }

                    Method (CNTL, 2, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.EIO.CMBT._STA (), 0x0F))
                        {
                            If (And (Arg0, 0x01))
                            {
                                If (And (Arg1, 0x01))
                                {
                                    Store (0x01, BRST)
                                }
                                Else
                                {
                                    Store (0x00, BRST)
                                }
                            }

                            If (And (Arg0, 0x02))
                            {
                                If (And (Arg1, 0x02))
                                {
                                    Store (0x01, BLON)
                                }
                                Else
                                {
                                    Store (0x00, BLON)
                                }
                            }

                            If (And (Arg0, 0x04))
                            {
                                If (And (Arg1, 0x04))
                                {
                                    Store (0x01, DVID)
                                    Store (0x94, CMD)
                                    Store (Zero, SSMI)
                                }
                                Else
                                {
                                    Store (0x00, DVID)
                                    Store (0x94, CMD)
                                    Store (Zero, SSMI)
                                }
                            }

                            If (And (Arg0, 0x18))
                            {
                                If (And (Arg1, 0x08))
                                {
                                    Store (0x00, WANT)
                                    Store (0x01, WLBT)
                                }

                                If (And (Arg1, 0x10))
                                {
                                    Store (0x00, WLRF)
                                    Store (0x01, WANT)
                                    Store (0x00, WLBT)
                                }

                                If (LNot (And (Arg1, 0x18)))
                                {
                                    Store (0x00, WLRF)
                                    Store (0x01, WANT)
                                    Store (0x01, WLBT)
                                }
                            }
                        }
                    }
                }

                Field (PIRQ, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   4, 
                    PIRB,   4, 
                    PIRC,   4, 
                    PIRD,   4, 
                    PIRE,   4, 
                    PIRF,   4, 
                    PIRG,   4, 
                    PIRH,   4
                }

                Field (PIR2, ByteAcc, NoLock, Preserve)
                {
                    PIRU,   4
                }

                Name (CVPI, Buffer (0x10)
                {
                    0x00, 0x09, 0x03, 0x0A, 0x04, 0x05, 0x07, 0x06, 
                    0x01, 0x0B, 0x00, 0x0C, 0x00, 0x0E, 0x00, 0x0F
                })
                Name (CVIP, Buffer (0x10)
                {
                    0x00, 0x08, 0x00, 0x02, 0x04, 0x05, 0x07, 0x06, 
                    0x00, 0x01, 0x03, 0x09, 0x0B, 0x00, 0x0D, 0x0F
                })
                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRA)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRA, IRQA)
                        If (IRQA)
                        {
                            ShiftLeft (One, IRQA, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQA)
                            Store (IRQA, PIRA)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRA)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRB)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRB, IRQB)
                        If (IRQB)
                        {
                            ShiftLeft (One, IRQB, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQB)
                            Store (IRQB, PIRB)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRB)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRC)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRC, IRQC)
                        If (IRQC)
                        {
                            ShiftLeft (One, IRQC, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQC)
                            Store (IRQC, PIRC)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRC)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRD)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRD, IRQD)
                        If (IRQD)
                        {
                            ShiftLeft (One, IRQD, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQD)
                            Store (IRQD, PIRD)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRD)
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRE)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRE, IRQE)
                        If (IRQE)
                        {
                            ShiftLeft (One, IRQE, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQE)
                            Store (IRQE, PIRE)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRE)
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRF)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRF, IRQF)
                        If (IRQF)
                        {
                            ShiftLeft (One, IRQF, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQF)
                            Store (IRQF, PIRF)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRF)
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRG)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRG, IRQG)
                        If (IRQG)
                        {
                            ShiftLeft (One, IRQG, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQG)
                            Store (IRQG, PIRG)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRG)
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRH)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRH, IRQH)
                        If (IRQH)
                        {
                            ShiftLeft (One, IRQH, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQH)
                            Store (IRQH, PIRH)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRH)
                    }
                }

                Device (LNKU)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x09)
                    Name (RSRC, Buffer (0x06)
                    {
                        0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                    })
                    Method (_PRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (IRQF, IRQ0)
                        Return (RSRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRU)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        CreateByteField (CVPI, PIRU, IRQU)
                        If (IRQU)
                        {
                            ShiftLeft (One, IRQU, IRQ0)
                        }
                        Else
                        {
                            Store (Zero, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        If (FindSetRightBit (IRQ0, Local0))
                        {
                            Decrement (Local0)
                            CreateByteField (CVIP, Local0, IRQU)
                            Store (IRQU, PIRU)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (Zero, PIRU)
                    }
                }
            }

            Device (USB)
            {
                Name (_ADR, 0x00020000)
                Name (_PR0, Package (0x01)
                {
                    USBP
                })
                Name (_PR1, Package (0x01)
                {
                    USBP
                })
                Name (_PR2, Package (0x01)
                {
                    USBP
                })
                PowerResource (USBP, 0x01, 0x0000)
                {
                    Name (RSTA, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (RSTA)
                    }

                    Method (_ON, 0, NotSerialized)
                    {
                        Store (One, RSTA)
                    }

                    Method (_OFF, 0, NotSerialized)
                    {
                        Store (Zero, RSTA)
                    }
                }
            }

            Device (IDE)
            {
                Name (_ADR, 0x000F0000)
                OperationRegion (ATIO, SystemIO, 0x0177, 0x01)
                Field (ATIO, ByteAcc, NoLock, Preserve)
                {
                    STSR,   8
                }

                OperationRegion (PCI, PCI_Config, 0x40, 0x20)
                Field (PCI, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x0B), 
                    U66E,   1, 
                    Offset (0x14), 
                    PFP0,   4, 
                    PFP1,   4, 
                    PFS0,   4, 
                    PFS1,   4, 
                    UMP0,   3, 
                    UEP0,   1, 
                    UMP1,   3, 
                    UEP1,   1, 
                    UMS0,   3, 
                    UES0,   1, 
                    UMS1,   3, 
                    UES1,   1, 
                    PCAS,   8, 
                    PCCB,   8, 
                    PDT0,   8, 
                    PDT1,   8, 
                    SCAS,   8, 
                    SCCB,   8, 
                    SDT0,   8, 
                    SDT1,   8
                }

                Name (XUDT, Package (0x05)
                {
                    0x04, 
                    0x03, 
                    0x02, 
                    0x01, 
                    0x00
                })
                Name (TUDT, Package (0x05)
                {
                    0x04, 
                    0x03, 
                    0x02, 
                    0x01, 
                    0x00
                })
                Name (TUDM, Package (0x05)
                {
                    0x1E, 
                    0x2D, 
                    0x3C, 
                    0x5A, 
                    0x78
                })
                Name (TPIO, Package (0x05)
                {
                    0x78, 
                    0xB4, 
                    0xF0, 
                    0x017F, 
                    0x0258
                })
                Name (TCBT, Package (0x05)
                {
                    0xAA, 
                    0xA3, 
                    0xA1, 
                    0x33, 
                    0x31
                })
                Name (TDRT, Package (0x05)
                {
                    0x88, 
                    0x58, 
                    0x44, 
                    0x33, 
                    0x31
                })
                Name (XMWD, Package (0x05)
                {
                    0x00, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x02
                })
                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (GTFB, Buffer (0x15)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, 0x00, 
                                0x00, 0x00, 0x00, 0xA0, 0xF5
                            })
                            CreateByteField (GTFB, 0x01, SPIO)
                            CreateByteField (GTFB, 0x06, SCM0)
                            CreateByteField (GTFB, 0x08, SDMA)
                            CreateByteField (GTFB, 0x0D, SCM1)
                            CreateByteField (GTFB, 0x14, SCM2)
                            If (LNot (SSUP ()))
                            {
                                Store (Zero, SCM2)
                            }

                            Store (Match (TDRT, MEQ, PDT0, MTR, 0x00, 0x00), Local0)
                            If (LEqual (Local0, Ones))
                            {
                                Store (Zero, SCM0)
                            }
                            Else
                            {
                                Or (Local0, 0x08, SPIO)
                            }

                            If (UEP0)
                            {
                                Or (DerefOf (Index (XUDT, UMP0)), 0x40, SDMA)
                            }
                            Else
                            {
                                If (LEqual (Local0, Ones))
                                {
                                    Store (Zero, SCM1)
                                }
                                Else
                                {
                                    Or (DerefOf (Index (XMWD, Local0)), 0x20, SDMA)
                                }
                            }

                            Return (GTFB)
                        }
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (GTMB, Buffer (0x14) {})
                        CreateDWordField (GTMB, 0x00, PIO0)
                        CreateDWordField (GTMB, 0x04, DMA0)
                        CreateDWordField (GTMB, 0x08, PIO1)
                        CreateDWordField (GTMB, 0x0C, DMA1)
                        CreateDWordField (GTMB, 0x10, FLAG)
                        Store (0x10, FLAG)
                        Store (Ones, PIO1)
                        Store (Ones, DMA1)
                        Store (Match (TDRT, MEQ, PDT0, MTR, 0x00, 0x00), Local0)
                        If (LEqual (Local0, Ones))
                        {
                            Store (Ones, PIO0)
                        }
                        Else
                        {
                            Subtract (0x04, Local0, Local1)
                            Store (DerefOf (Index (TPIO, Local1)), PIO0)
                            If (LNot (LLess (Local0, 0x03)))
                            {
                                Or (FLAG, 0x02, FLAG)
                            }
                        }

                        If (UEP0)
                        {
                            Subtract (0x04, DerefOf (Index (XUDT, UMP0)), Local1)
                            Store (DerefOf (Index (TUDM, Local1)), DMA0)
                            Or (FLAG, 0x01, FLAG)
                        }
                        Else
                        {
                            Store (PIO0, DMA0)
                        }

                        Return (GTMB)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        If (LAnd (PSMF (), LEqual (SizeOf (Arg1), 0x0200)))
                        {
                            CreateBitField (Arg1, 0x031B, SIOR)
                            CreateBitField (Arg1, 0x0338, SPI0)
                            CreateBitField (Arg1, 0x0339, SPI1)
                            CreateBitField (Arg1, 0x033A, SPI2)
                            CreateBitField (Arg1, 0x0351, W64V)
                            CreateBitField (Arg1, 0x0352, W88V)
                            CreateBitField (Arg1, 0x03F0, SMD0)
                            CreateBitField (Arg1, 0x03F1, SMD1)
                            CreateBitField (Arg1, 0x03F2, SMD2)
                            CreateBitField (Arg1, 0x0400, SPI3)
                            CreateBitField (Arg1, 0x0401, SPI4)
                            CreateByteField (Arg1, 0xB0, SUDM)
                            Store (Zero, PFP0)
                            Store (Zero, PFP1)
                            Store (Zero, UEP0)
                            Store (Zero, UMP0)
                            Store (Zero, UEP1)
                            Store (Zero, UMP1)
                            Store (Zero, PCAS)
                            Store (Zero, PCCB)
                            Store (Zero, PDT0)
                            Store (Zero, PDT1)
                            If (LNot (LEqual (PIO0, 0xFFFFFFFF)))
                            {
                                Store (Match (TPIO, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                                If (LEqual (Local0, Ones))
                                {
                                    Store (Zero, Local0)
                                }
                                Else
                                {
                                    Subtract (0x04, Local0, Local0)
                                }

                                If (LAnd (LNot (LLess (Local0, 0x04)), LAnd (W64V, SPI4)))
                                {
                                    Store (0x04, Local1)
                                }
                                Else
                                {
                                    If (LAnd (LNot (LLess (Local0, 0x03)), LAnd (W64V, SPI3)))
                                    {
                                        Store (0x03, Local1)
                                    }
                                    Else
                                    {
                                        If (LAnd (LNot (LLess (Local0, 0x02)), SPI2))
                                        {
                                            Store (0x02, Local1)
                                        }
                                        Else
                                        {
                                            If (LAnd (LNot (LLess (Local0, One)), SPI1))
                                            {
                                                Store (One, Local1)
                                            }
                                            Else
                                            {
                                                Store (Zero, Local1)
                                            }
                                        }
                                    }
                                }

                                Store (DerefOf (Index (TCBT, Local1)), PCCB)
                                Store (DerefOf (Index (TDRT, Local1)), PDT0)
                                If (^MAST.UFIF ())
                                {
                                    Store (0x05, PFP0)
                                }
                            }

                            If (LNot (LEqual (DMA0, 0xFFFFFFFF)))
                            {
                                If (LAnd (And (FLAG, 0x01), LAnd (W88V, And (SUDM, 0x3F))))
                                {
                                    Store (Match (TUDM, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                    If (LEqual (Local0, Ones))
                                    {
                                        Store (Zero, Local0)
                                    }
                                    Else
                                    {
                                        Subtract (0x04, Local0, Local0)
                                    }

                                    ShiftLeft (One, Local0, Local1)
                                    While (LAnd (LNot (And (SUDM, Local1)), Local0))
                                    {
                                        ShiftRight (Local1, One, Local1)
                                        Decrement (Local0)
                                    }

                                    Store (DerefOf (Index (TUDT, Local0)), UMP0)
                                    Store (One, UEP0)
                                }
                                Else
                                {
                                    Store (Match (TPIO, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                                    If (LEqual (Local0, Ones))
                                    {
                                        Store (Zero, Local0)
                                    }
                                    Else
                                    {
                                        Subtract (0x04, Local0, Local0)
                                    }

                                    If (LAnd (LNot (LLess (Local0, 0x04)), SMD2))
                                    {
                                        Store (0x04, Local1)
                                    }
                                    Else
                                    {
                                        If (LAnd (LNot (LLess (Local0, 0x03)), SMD1))
                                        {
                                            Store (0x03, Local1)
                                        }
                                        Else
                                        {
                                            Store (0x02, Local1)
                                        }
                                    }

                                    Store (DerefOf (Index (TCBT, Local1)), PCCB)
                                    Store (DerefOf (Index (TDRT, Local1)), PDT0)
                                }
                            }
                        }
                    }
                }

                Device (SECN)
                {
                    Name (_ADR, 0x01)
                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (GTFB, Buffer (0x15)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, 0x00, 
                                0x00, 0x00, 0x00, 0xA0, 0xF5
                            })
                            CreateByteField (GTFB, 0x01, SPIO)
                            CreateByteField (GTFB, 0x06, SCM0)
                            CreateByteField (GTFB, 0x08, SDMA)
                            CreateByteField (GTFB, 0x0D, SCM1)
                            CreateByteField (GTFB, 0x14, SCM2)
                            If (LNot (SSUP ()))
                            {
                                Store (Zero, SCM2)
                            }

                            Store (Match (TDRT, MEQ, SDT0, MTR, 0x00, 0x00), Local0)
                            If (LEqual (Local0, Ones))
                            {
                                Store (Zero, SCM0)
                            }
                            Else
                            {
                                Or (Local0, 0x08, SPIO)
                            }

                            If (UES0)
                            {
                                Or (DerefOf (Index (XUDT, UMS0)), 0x40, SDMA)
                            }
                            Else
                            {
                                If (LEqual (Local0, Ones))
                                {
                                    Store (Zero, SCM1)
                                }
                                Else
                                {
                                    Or (DerefOf (Index (XMWD, Local0)), 0x20, SDMA)
                                }
                            }

                            Return (GTFB)
                        }
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (GTMB, Buffer (0x14) {})
                        CreateDWordField (GTMB, 0x00, PIO0)
                        CreateDWordField (GTMB, 0x04, DMA0)
                        CreateDWordField (GTMB, 0x08, PIO1)
                        CreateDWordField (GTMB, 0x0C, DMA1)
                        CreateDWordField (GTMB, 0x10, FLAG)
                        Store (0x10, FLAG)
                        Store (Ones, PIO1)
                        Store (Ones, DMA1)
                        Store (Match (TDRT, MEQ, SDT0, MTR, 0x00, 0x00), Local0)
                        If (LEqual (Local0, Ones))
                        {
                            Store (Ones, PIO0)
                        }
                        Else
                        {
                            Subtract (0x04, Local0, Local1)
                            Store (DerefOf (Index (TPIO, Local1)), PIO0)
                            If (LNot (LLess (Local0, 0x03)))
                            {
                                Or (FLAG, 0x02, FLAG)
                            }
                        }

                        If (UES0)
                        {
                            Subtract (0x04, DerefOf (Index (XUDT, UMS0)), Local1)
                            Store (DerefOf (Index (TUDM, Local1)), DMA0)
                            Or (FLAG, 0x01, FLAG)
                        }
                        Else
                        {
                            Store (PIO0, DMA0)
                        }

                        Return (GTMB)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        If (LAnd (SSMF (), LEqual (SizeOf (Arg1), 0x0200)))
                        {
                            CreateBitField (Arg1, 0x031B, SIOR)
                            CreateBitField (Arg1, 0x0338, SPI0)
                            CreateBitField (Arg1, 0x0339, SPI1)
                            CreateBitField (Arg1, 0x033A, SPI2)
                            CreateBitField (Arg1, 0x0351, W64V)
                            CreateBitField (Arg1, 0x0352, W88V)
                            CreateBitField (Arg1, 0x03F0, SMD0)
                            CreateBitField (Arg1, 0x03F1, SMD1)
                            CreateBitField (Arg1, 0x03F2, SMD2)
                            CreateBitField (Arg1, 0x0400, SPI3)
                            CreateBitField (Arg1, 0x0401, SPI4)
                            CreateByteField (Arg1, 0xB0, SUDM)
                            Store (Zero, PFS0)
                            Store (Zero, PFS1)
                            Store (Zero, UES0)
                            Store (Zero, UMS0)
                            Store (Zero, UES1)
                            Store (Zero, UMS1)
                            Store (Zero, SCAS)
                            Store (Zero, SCCB)
                            Store (Zero, SDT0)
                            Store (Zero, SDT1)
                            If (LNot (LEqual (PIO0, 0xFFFFFFFF)))
                            {
                                Store (Match (TPIO, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                                If (LEqual (Local0, Ones))
                                {
                                    Store (Zero, Local0)
                                }
                                Else
                                {
                                    Subtract (0x04, Local0, Local0)
                                }

                                If (LAnd (LNot (LLess (Local0, 0x04)), LAnd (W64V, SPI4)))
                                {
                                    Store (0x04, Local1)
                                }
                                Else
                                {
                                    If (LAnd (LNot (LLess (Local0, 0x03)), LAnd (W64V, SPI3)))
                                    {
                                        Store (0x03, Local1)
                                    }
                                    Else
                                    {
                                        If (LAnd (LNot (LLess (Local0, 0x02)), SPI2))
                                        {
                                            Store (0x02, Local1)
                                        }
                                        Else
                                        {
                                            If (LAnd (LNot (LLess (Local0, One)), SPI1))
                                            {
                                                Store (One, Local1)
                                            }
                                            Else
                                            {
                                                Store (Zero, Local1)
                                            }
                                        }
                                    }
                                }

                                Store (DerefOf (Index (TCBT, Local1)), SCCB)
                                Store (DerefOf (Index (TDRT, Local1)), SDT0)
                                If (^MAST.UFIF ())
                                {
                                    Store (0x05, PFS0)
                                }
                            }

                            If (LNot (LEqual (DMA0, 0xFFFFFFFF)))
                            {
                                If (LAnd (And (FLAG, 0x01), LAnd (W88V, And (SUDM, 0x3F))))
                                {
                                    Store (Match (TUDM, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                    If (LEqual (Local0, Ones))
                                    {
                                        Store (Zero, Local0)
                                    }
                                    Else
                                    {
                                        Subtract (0x04, Local0, Local0)
                                    }

                                    ShiftLeft (One, Local0, Local1)
                                    While (LAnd (LNot (And (SUDM, Local1)), Local0))
                                    {
                                        ShiftRight (Local1, One, Local1)
                                        Decrement (Local0)
                                    }

                                    Store (DerefOf (Index (TUDT, Local0)), UMS0)
                                    Store (One, UES0)
                                }
                                Else
                                {
                                    Store (Match (TPIO, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                                    If (LEqual (Local0, Ones))
                                    {
                                        Store (Zero, Local0)
                                    }
                                    Else
                                    {
                                        Subtract (0x04, Local0, Local0)
                                    }

                                    If (LAnd (LNot (LLess (Local0, 0x04)), SMD2))
                                    {
                                        Store (0x04, Local1)
                                    }
                                    Else
                                    {
                                        If (LAnd (LNot (LLess (Local0, 0x03)), SMD1))
                                        {
                                            Store (0x03, Local1)
                                        }
                                        Else
                                        {
                                            Store (0x02, Local1)
                                        }
                                    }

                                    Store (DerefOf (Index (TCBT, Local1)), SCCB)
                                    Store (DerefOf (Index (TDRT, Local1)), SDT0)
                                }
                            }
                        }
                    }
                }

                Method (PSMF, 0, NotSerialized)
                {
                    Return (One)
                }

                Method (SSMF, 0, NotSerialized)
                {
                    Return (\_SB.PCI0.IDE.SECN.MAST._STA ())
                }

                Scope (\_SB.PCI0.IDE.PRIM)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Scope (\_SB.PCI0.IDE.PRIM.MAST)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (SSUP, 0, NotSerialized)
                    {
                        Return (One)
                    }

                    Method (UFIF, 0, NotSerialized)
                    {
                        Return (One)
                    }
                }

                Scope (\_SB.PCI0.IDE.SECN)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (BYIF, Ones))
                        {
                            Store (Zero, BYIF)
                            If (LNot (\_SB.PCI0.IDE.SECN.MAST._STA ()))
                            {
                                TMMX ()
                                CHEN (One)
                                STTM (Zero)
                                Store (One, BYRF)
                            }
                        }

                        Return (0x0F)
                    }

                    Method (STTM, 1, NotSerialized)
                    {
                        Store (One, BYDF)
                        Store (0x03, ESHE)
                        Store (0x41, HBTC)
                        Store (One, HBTE)
                    }

                    Method (CHEN, 1, NotSerialized)
                    {
                        Store (0x95, CMD)
                        Store (Arg0, DVID)
                        Store (Zero, SSMI)
                    }

                    Method (TMCL, 0, NotSerialized)
                    {
                        Store (Zero, PFS0)
                        Store (Zero, PFS1)
                        Store (Zero, UES0)
                        Store (Zero, UMS0)
                        Store (Zero, UES1)
                        Store (Zero, UMS1)
                        Store (Zero, SCAS)
                        Store (Zero, SCCB)
                        Store (Zero, SDT0)
                        Store (Zero, SDT1)
                    }

                    Method (TMMX, 0, NotSerialized)
                    {
                        Store (One, UES0)
                        Store (Zero, UMS0)
                        Store (0x31, SCCB)
                        Store (0x31, SDT0)
                    }
                }

                Scope (\_SB.PCI0.IDE.SECN.MAST)
                {
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LAnd (BIDE (), BYPW))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (SSUP, 0, NotSerialized)
                    {
                        Return (Zero)
                    }

                    Method (UFIF, 0, NotSerialized)
                    {
                        Return (Zero)
                    }

                    Method (BIDE, 0, NotSerialized)
                    {
                        If (BYI2)
                        {
                            If (LEqual (BYI1, 0x03))
                            {
                                Return (One)
                            }
                        }

                        Return (Zero)
                    }

                    Method (_EJ0, 1, NotSerialized)
                    {
                        BOFF ()
                        Return (Zero)
                    }

                    Method (BON, 0, NotSerialized)
                    {
                        If (LNot (LOr (BYS1, BYS2)))
                        {
                            If (BIDE ())
                            {
                                Store (One, BYPW)
                                Sleep (0x0A)
                                TMMX ()
                                CHEN (One)
                                Sleep (0x07D0)
                                Store (Zero, CDLP)
                                If (LEqual (BIDE (), One))
                                {
                                    Or (CDLP, 0x04, CDLP)
                                }
                            }
                        }
                    }

                    Method (BOFF, 0, NotSerialized)
                    {
                        CHEN (Zero)
                        Store (Zero, BYPW)
                        Sleep (0xFA)
                        TMCL ()
                        Store (Zero, CDLP)
                    }
                }

                Name (_PSC, 0x00)
                Method (_PS0, 0, NotSerialized)
                {
                    Store (0x00, _PSC)
                    If (LAnd (SCEF, LEqual (\TOOS (), 0x03)))
                    {
                        \_SB.PCI0.IDE.SECN.CHEN (One)
                    }

                    Store (Zero, SCEF)
                }

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

            Device (AUD)
            {
                Name (_ADR, 0x00040000)
            }

            Device (VGA)
            {
                Name (_ADR, 0x00140000)
                Scope (\)
                {
                    Name (DISF, One)
                    Name (HKYF, Zero)
                    Name (WLCD, Zero)
                    Name (WCRT, Zero)
                    Name (WTV, Zero)
                }

                Method (PHTK, 0, NotSerialized)
                {
                    XOr (DISF, One, DVID)
                }

                Method (AHTK, 0, NotSerialized)
                {
                    If (LEqual (DISF, Zero))
                    {
                        If (And (DVID, 0x80))
                        {
                            CHGD ()
                        }
                        Else
                        {
                            If (And (DVID, 0x40))
                            {
                                CHGT ()
                            }
                        }
                    }
                }

                Method (CHGD, 0, NotSerialized)
                {
                    If (LNot (ACRT))
                    {
                        Store (One, Local0)
                    }
                    Else
                    {
                        And (Add (Or (ShiftLeft (CCRT, 0x01), CLCD), One), 0x03, Local0)
                        If (LNot (Local0))
                        {
                            Store (One, Local0)
                        }
                    }

                    And (Local0, One, WLCD)
                    ShiftRight (And (Local0, 0x02), 0x01, WCRT)
                    And (CTV, ATV, WTV)
                    Store (0x80, HKYF)
                    Notify (VGA, 0x80)
                }

                Method (CHGT, 0, NotSerialized)
                {
                    Store (CLCD, WLCD)
                    And (CCRT, ACRT, WCRT)
                    And (XOr (CTV, One), ATV, WTV)
                    If (Or (WTV, Or (WCRT, WLCD)))
                    {
                        Store (Zero, HKYF)
                        Notify (VGA, 0x80)
                    }
                }

                Method (ADJD, 0, NotSerialized)
                {
                    Or (HKYF, Or (Or (ShiftLeft (WTV, 0x02), ShiftLeft (WCRT, 0x01)), WLCD), DVID)
                    Store (0x8E, CMD)
                    Store (Zero, SSMI)
                }

                Method (_DOS, 1, NotSerialized)
                {
                    Store (Arg0, DISF)
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Return (Package (0x03)
                    {
                        0x00010100, 
                        0x00010110, 
                        0x00010200
                    })
                }

                Device (CRT)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0100)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        Return (Or (0x0D, Or (ShiftLeft (ACRT, 0x04), ShiftLeft (CCRT, 0x01))))
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WCRT)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (And (Arg0, 0x80000000))
                        {
                            ADJD ()
                        }
                    }
                }

                Device (LCD)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0110)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        Return (Or (0x0D, Or (ShiftLeft (ALCD, 0x04), ShiftLeft (CLCD, 0x01))))
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WLCD)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (And (Arg0, 0x80000000))
                        {
                            ADJD ()
                        }
                    }
                }

                Device (TV)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0200)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        Return (Or (0x0D, Or (ShiftLeft (ATV, 0x04), ShiftLeft (CTV, 0x01))))
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        Return (WTV)
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        If (And (Arg0, 0x80000000))
                        {
                            ADJD ()
                        }
                    }
                }
            }

            Device (EMB1)
            {
                Name (_ADR, 0x00120000)
            }

            Device (OLAN)
            {
                Name (_ADR, 0x00100000)
                OperationRegion (PCI, PCI_Config, 0x00, 0x04)
                Field (PCI, ByteAcc, NoLock, Preserve)
                {
                    VID,    32
                }

                Method (_INI, 0, NotSerialized)
                {
                    If (LEqual (VID, 0x813910EC))
                    {
                        Store (Zero, RI1M)
                    }
                }
            }

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

            Device (USB2)
            {
                Name (_ADR, 0x00090001)
            }

            Device (USB3)
            {
                Name (_ADR, 0x00090002)
            }

            Device (CRD0)
            {
                Name (_ADR, 0x000C0000)
                OperationRegion (CCRD, PCI_Config, 0x40, 0x54)
                Field (CCRD, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x04), 
                    CD44,   16, 
                    Offset (0x51), 
                        ,   7, 
                    RIE,    1
                }

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

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
        }

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Scope (\)
            {
                Name (ACPS, Ones)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (ACPW, ACPS)
            }

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

            Method (_PSR, 0, NotSerialized)
            {
                _INI ()
                If (ACPW)
                {
                    Return (One)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (ACHK, 0, NotSerialized)
            {
                Store (ACPW, Local0)
                If (LNot (LEqual (Local0, ACPS)))
                {
                    Sleep (0x28)
                    Notify (\_SB.AC, 0x80)
                    Store (Local0, ACPS)
                }
            }
        }

        Device (CMB1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, One)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Scope (\)
            {
                Name (B1PS, Ones)
                Name (B1RS, Ones)
                Name (B1CS, Ones)
                Name (BIF1, Package (0x0D)
                {
                    0x01, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x2A30, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x01, 
                    "", 
                    "1", 
                    "LION", 
                    "Fujitsu"
                })
                Name (BST1, Package (0x04) {})
            }

            Method (MKWD, 2, NotSerialized)
            {
                If (And (Arg1, 0x80))
                {
                    Or (0xFFFF0000, Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                    Subtract (Zero, Local0, Local0)
                }
                Else
                {
                    Store (Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                }

                Return (Local0)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (B1P, B1PS)
                Store (B1CP, B1RS)
                Store (B1C, B1CS)
            }

            Method (_BIF, 0, NotSerialized)
            {
                CreateByteField (BIDT, B1ID, B1IX)
                Store (DerefOf (Index (BDCT, B1IX)), Index (BIF1, One))
                Store (DerefOf (Index (BDCT, B1IX)), Index (BIF1, 0x02))
                Store (DerefOf (Index (BMNT, B1IX)), Index (BIF1, 0x09))
                Return (BIF1)
            }

            Method (_BST, 0, NotSerialized)
            {
                _INI ()
                Store (Zero, Local0)
                If (B1P)
                {
                    If (B1C)
                    {
                        Or (Local0, 0x02, Local0)
                    }
                    Else
                    {
                        Or (Local0, One, Local0)
                    }

                    If (LNot (LGreater (B1CP, One)))
                    {
                        Or (Local0, 0x04, Local0)
                    }
                }

                Store (MKWD (B1CL, B1CH), Local1)
                CreateByteField (BIDT, B1ID, B1IX)
                Divide (Multiply (B1CP, DerefOf (Index (BDCT, B1IX))), 0x03E8, Local4, Local2)
                If (Local4)
                {
                    Increment (Local2)
                }

                Multiply (Local2, 0x0A, Local2)
                Store (MKWD (B1VL, B1VH), Local3)
                Store (Local0, Index (BST1, Zero))
                Store (Local1, Index (BST1, One))
                Store (Local2, Index (BST1, 0x02))
                Store (Local3, Index (BST1, 0x03))
                Return (BST1)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (B1P)
                {
                    Return (0x1F)
                }

                Return (0x0F)
            }

            Method (BCHK, 0, NotSerialized)
            {
                If (LNot (LEqual (B1P, B1PS)))
                {
                    Notify (\_SB.CMB1, 0x81)
                    Store (B1P, B1PS)
                }

                If (B1PS)
                {
                    If (LOr (LNot (LEqual (B1C, B1CS)), LNot (LEqual (B1CP, B1RS))))
                    {
                        Notify (\_SB.CMB1, 0x80)
                    }

                    Store (B1C, B1CS)
                    Store (B1CP, B1RS)
                }
            }
        }

        Device (CMB2)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x02)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Scope (\)
            {
                Name (B2PS, Ones)
                Name (B2RS, Ones)
                Name (B2CS, Ones)
                Name (BIF2, Package (0x0D)
                {
                    0x01, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x2A30, 
                    0x00, 
                    0x00, 
                    0x01, 
                    0x01, 
                    "", 
                    "2", 
                    "LION", 
                    "Fujitsu"
                })
                Name (BST2, Package (0x04) {})
            }

            Method (MKWD, 2, NotSerialized)
            {
                If (And (Arg1, 0x80))
                {
                    Or (0xFFFF0000, Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                    Subtract (Zero, Local0, Local0)
                }
                Else
                {
                    Store (Arg0, Local0)
                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
                }

                Return (Local0)
            }

            Method (_INI, 0, NotSerialized)
            {
                Store (B2P, B2PS)
                Store (B2CP, B2RS)
                Store (B2C, B2CS)
            }

            Method (_BIF, 0, NotSerialized)
            {
                CreateByteField (BIDT, B2ID, B2IX)
                Store (DerefOf (Index (BDCT, B2IX)), Index (BIF2, One))
                Store (DerefOf (Index (BDCT, B2IX)), Index (BIF2, 0x02))
                Store (DerefOf (Index (BMNT, B2IX)), Index (BIF2, 0x09))
                Return (BIF2)
            }

            Method (_BST, 0, NotSerialized)
            {
                _INI ()
                Store (Zero, Local0)
                If (B2P)
                {
                    If (B2C)
                    {
                        Or (Local0, 0x02, Local0)
                    }
                    Else
                    {
                        Or (Local0, One, Local0)
                    }

                    If (LNot (LGreater (B2CP, One)))
                    {
                        Or (Local0, 0x04, Local0)
                    }
                }

                Store (MKWD (B2CL, B2CH), Local1)
                CreateByteField (BIDT, B2ID, B2IX)
                Divide (Multiply (B2CP, DerefOf (Index (BDCT, B2IX))), 0x03E8, Local4, Local2)
                If (Local4)
                {
                    Increment (Local2)
                }

                Multiply (Local2, 0x0A, Local2)
                Store (MKWD (B2VL, B2VH), Local3)
                Store (Local0, Index (BST2, Zero))
                Store (Local1, Index (BST2, One))
                Store (Local2, Index (BST2, 0x02))
                Store (Local3, Index (BST2, 0x03))
                Return (BST2)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (B2P)
                {
                    Return (0x1F)
                }

                Return (0x0F)
            }

            Method (BCHK, 0, NotSerialized)
            {
                If (LNot (LEqual (B2P, B2PS)))
                {
                    Notify (\_SB.CMB1, 0x81)
                    Store (B2P, B2PS)
                }

                If (B2PS)
                {
                    If (LOr (LNot (LEqual (B2C, B2CS)), LNot (LEqual (B2CP, B2RS))))
                    {
                        Notify (\_SB.CMB2, 0x80)
                    }

                    Store (B2C, B2CS)
                    Store (B2CP, B2RS)
                }
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (CVCL)
                {
                    Return (Zero)
                }
                Else
                {
                    Return (One)
                }
            }

            Name (_PRW, Package (0x02)
            {
                0x02, 
                0x04
            })
            Method (_PSW, 1, NotSerialized)
            {
                Noop
            }
        }
    }

    Scope (_GPE)
    {
        Method (_L02, 0, NotSerialized)
        {
            Notify (\_SB.LID, 0x80)
        }

        Method (_L03, 0, NotSerialized)
        {
            Store (SSF0, Local0)
            Store (Local0, SSF0)
            And (Local0, Not (SSM0), Local0)
            Store (SSF1, Local1)
            Store (Local1, SSF1)
            And (Local1, Not (SSM1), Local1)
            Store (SSF2, Local2)
            Store (Local2, SSF2)
            And (Local2, Not (SSM2), Local2)
            If (And (Local2, 0x10))
            {
                \_SB.AC.ACHK ()
                \_SB.CMB1.BCHK ()
                \_SB.CMB2.BCHK ()
            }

            If (And (Local1, 0x40))
            {
                \_SB.PCI0.VGA.PHTK ()
                Store (0x80, CMD)
                Store (Zero, SSMI)
                \_SB.PCI0.VGA.AHTK ()
                If (AHKF)
                {
                    Notify (\_SB.PCI0.EIO.FJEX, 0x80)
                }
            }

            If (WAPB)
            {
                Notify (\_SB.PWRB, 0x02)
                Store (Zero, WAPB)
                Store (Zero, ERE3)
            }

            If (And (Local1, 0x10))
            {
                Notify (\_SB.PCI0.EIO.CMBT, 0x81)
            }

            If (And (Local1, 0x20))
            {
                Notify (\_SB.PCI0.EIO.CMBT, 0x82)
            }

            If (And (Local2, 0x08))
            {
                Store (TBSF, Local3)
                Store (Zero, STAE)
                If (Local3)
                {
                    Store (Zero, TBSM)
                    If (BYDF)
                    {
                        \_SB.PCI0.IDE.SECN.CHEN (Zero)
                        Store (Zero, BYDF)
                    }
                }
            }
        }

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

        Method (_L1A, 0, NotSerialized)
        {
            If (BYS1)
            {
                If (BYPW)
                {
                    \_SB.PCI0.IDE.SECN.MAST.BOFF ()
                    Notify (\_SB.PCI0.IDE.SECN.MAST, One)
                    Store (Zero, BYDF)
                }
            }
            Else
            {
                Store (Zero, BYDF)
                Store (0x10, Local0)
                While (LAnd (BYS2, Local0))
                {
                    Sleep (0x64)
                    Decrement (Local0)
                }

                \_SB.PCI0.IDE.SECN.MAST.BON ()
                If (BYPW)
                {
                    Notify (\_SB.PCI0.IDE.SECN.MAST, One)
                    If (LAnd (BYRF, LEqual (\TOOS (), 0x03)))
                    {
                        Sleep (0x07D0)
                        Notify (\_SB.PCI0.IDE.SECN.MAST, One)
                    }
                }

                Store (Zero, BYRF)
            }
        }

        Method (_L30, 0, NotSerialized)
        {
            If (LEqual (LRON, 0x01))
            {
                If (LEqual (THST, Zero))
                {
                    Store (0x07, LRRV)
                    Store (0x01, LREN)
                    Store (Zero, THLE)
                    Store (0x01, THHE)
                    Store (0x88, IO80)
                }
                Else
                {
                    Store (Zero, LREN)
                    Store (0x01, THLE)
                    Store (Zero, THHE)
                    Store (0x00, IO80)
                }
            }
        }
    }

    Name (_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x04)
    {
        0x06, 
        0x06, 
        0x00, 
        0x00
    })
    Name (_S4, Package (0x04)
    {
        0x07, 
        0x07, 
        0x00, 
        0x00
    })
    Name (_S5, Package (0x04)
    {
        0x07, 
        0x07, 
        0x00, 
        0x00
    })
    Method (_PTS, 1, NotSerialized)
    {
        If (LAnd (LNot (LLess (Arg0, One)), LNot (LGreater (Arg0, 0x04))))
        {
            Store (0x6D, BCTL)
            While (And (BCTL, One))
            {
                Sleep (One)
            }

            Store (0x81, CMD)
            Add (\TOOS (), ShiftLeft (Arg0, 0x08), DVID)
            Store (Zero, SSMI)
            Store (0x88, CMD)
            Store (Zero, SSMI)
            Store (0x8F, CMD)
            Store (Zero, SSMI)
            If (\_SB.PCI0.IDE.SECN.MAST._STA ())
            {
                Store (Or (ShiftLeft (BYI2, 0x03), BYI1), BYIS)
            }
            Else
            {
                Store (0xFF, BYIS)
            }

            Store (One, SCEF)
        }

        If (LNot (LEqual (Arg0, 0x05)))
        {
            Store (Zero, EFE2)
        }

        Store (WLBT, ANTS)
        If (LNot (LLess (Arg0, 0x03)))
        {
            Store (0x9F, APAC)
            Store (One, APAE)
        }

        Store (Zero, WAPB)
    }

    Method (_WAK, 1, NotSerialized)
    {
        If (LOr (LEqual (Arg0, One), LEqual (Arg0, 0x03)))
        {
            Store (0x83, CMD)
            Store (Zero, SSMI)
        }

        If (WAPB)
        {
            Store (One, ERE3)
            Store (Zero, ERE3)
        }

        \_SB.PCI0.PWR._INI ()
        \_SB.PCI0.EIO._INI ()
        \_SB.PCI0.OLAN._INI ()
        If (LEqual (\_SB.PCI0.EIO.CMBT._STA (), 0x0F))
        {
            \_SB.PCI0.EIO.CMBT._INI ()
        }

        Store (ANTS, WLBT)
        If (LAnd (LNot (LLess (Arg0, One)), LNot (LGreater (Arg0, 0x04))))
        {
            If (LEqual (BYIS, 0xFF))
            {
                If (\_SB.PCI0.IDE.SECN.MAST.BIDE ())
                {
                    \_SB.PCI0.IDE.SECN.MAST.BON ()
                    If (BYPW)
                    {
                        Notify (\_SB.PCI0.IDE.SECN.MAST, One)
                    }
                }
                Else
                {
                    If (LEqual (\TOOS (), 0x03))
                    {
                        \_SB.PCI0.IDE.SECN.STTM (Zero)
                    }
                }
            }
            Else
            {
                If (LNot (\_SB.PCI0.IDE.SECN.MAST._STA ()))
                {
                    \_SB.PCI0.IDE.SECN.TMCL ()
                    Notify (\_SB.PCI0.IDE.SECN.MAST, One)
                    \_SB.PCI0.IDE.SECN.STTM (Zero)
                }
            }
        }

        Return (Zero)
    }
}


Kernel Config
-------------------------------------------------------------------

makeoptions	KERNEL=P2120
machine		i386
cpu		I586_CPU
ident		P2120
makeoptions	DEBUG=-g		#Build kernel with gdb(1) debug symbols
options 	SCHED_ULE
options 	INET			#InterNETworking
options 	FFS			#Berkeley Fast Filesystem
options 	SOFTUPDATES		#Enable FFS soft updates support
options 	UFS_ACL			#Support for access control lists
options 	UFS_DIRHASH		#Improve performance on big directories
options 	NFSCLIENT		#Network Filesystem Client
options 	CD9660			#ISO 9660 Filesystem
options 	PROCFS			#Process filesystem (requires PSEUDOFS)
options 	PSEUDOFS		#Pseudo-filesystem framework
options 	COMPAT_43		#Compatible with BSD 4.3 [KEEP THIS!]
options 	COMPAT_FREEBSD4		#Compatible with FreeBSD4
options		COMPAT_LINUX
options		LINPROCFS
options 	SCSI_DELAY=1000		#Delay (in ms) before probing SCSI
options 	KTRACE			#ktrace(1) support
options 	SYSVSHM			#SYSV-style shared memory
options 	SYSVMSG			#SYSV-style message queues
options 	SYSVSEM			#SYSV-style semaphores
options 	_KPOSIX_PRIORITY_SCHEDULING #Posix P1003_1B real-time extensions
options 	KBD_INSTALL_CDEV	# install a CDEV entry in /dev
options 	AHC_REG_PRETTY_PRINT	# Print register bitfields in debug
					# output.  Adds ~128k to driver.
options 	AHD_REG_PRETTY_PRINT	# Print register bitfields in debug
					# output.  Adds ~215k to driver.
options 	DDB			#Enable the kernel debugger
options 	INVARIANTS		#Enable calls of extra sanity checking
options 	INVARIANT_SUPPORT	#Extra sanity checks of internal structures, required by INVARIANTS
device		isa
device		pci
device		fdc
device		ata
device		atadisk			# ATA disk drives
device		atapicd			# ATAPI CDROM drives
options 	ATA_STATIC_ID		#Static device numbering
device		scbus		# SCSI bus (required for SCSI)
device		da		# Direct Access (disks)
device		pass		# Passthrough device (direct SCSI access)
device		atkbdc		# AT keyboard controller
device		atkbd		# AT keyboard
device		psm		# PS/2 mouse
device		vga		# VGA video card driver
device		splash		# Splash screen and screen saver support
device		sc
device		agp		# support several AGP chipsets
device		npx
device		cbb			# cardbus (yenta) bridge
device		pccard			# PC Card (16-bit) bus
device		cardbus			# CardBus (32-bit) bus
device		miibus		# MII bus support
device		rl		# RealTek 8129/8139
device		ed		# NE[12]000, SMC Ultra, 3c503, DS8390 cards
device		wlan		# 802.11 support
device		wi		# WaveLAN/Intersil/Symbol 802.11 wireless NICs.
device		random		# Entropy device
device		loop		# Network loopback
device		ether		# Ethernet support
device		sl		# Kernel SLIP
device		ppp		# Kernel PPP
device		tun		# Packet tunnel.
device		pty		# Pseudo-ttys (telnet etc)
device		bpf		# Berkeley packet filter
device		firewire	# FireWire bus code
device		radeondrm
options 	NETSMB			#SMB/CIFS requester
options 	NETSMBCRYPTO		#encrypted passw
options 	LIBMCHAIN
options 	SMBFS			#SMB/CIFS filesystem
				# needs CAM to be present (scbus & pass)
device		pcm
options 	LIBICONV
device		iicbus		# Bus support, required for ic/iic/iicsmb below.
device		ehci
device		ohci
device		usb
options 	USB_DEBUG
options 	IPFIREWALL		#firewall
options 	IPFIREWALL_VERBOSE	#enable logging to syslogd(8)
options 	IPFIREWALL_VERBOSE_LIMIT=100	#limit verbosity
options		IPDIVERT
Received on Fri Jan 16 2004 - 11:44:28 UTC

This archive was generated by hypermail 2.4.0 : Wed May 19 2021 - 11:37:38 UTC