
ne2000.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_ProbeAddressForNIC>:
 * NOTES:
 *     If the adapter responds correctly to a
 *     stop command we assume it is present
 */
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	53                   	push   %ebx
   11004:	83 ec 0c             	sub    $0xc,%esp
   11007:	8b 5d 08             	mov    0x8(%ebp),%ebx
    UCHAR Tmp;

    NDIS_DbgPrint(MID_TRACE, ("Probing address 0x%x\n", address));

    /* Disable interrupts */
    NdisRawWritePortUchar(address + PG0_IMR, 0);
   1100a:	6a 00                	push   $0x0
   1100c:	8d 43 0f             	lea    0xf(%ebx),%eax
   1100f:	50                   	push   %eax
   11010:	e8 db 20 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Stop the NIC */
    NdisRawWritePortUchar(address + PG0_CR, CR_STP | CR_RD2);
   11015:	6a 21                	push   $0x21
   11017:	53                   	push   %ebx
   11018:	e8 d3 20 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Pause for 1.6ms */
    NdisStallExecution(1600);
   1101d:	50                   	push   %eax
   1101e:	68 40 06 00 00       	push   $0x640
   11023:	e8 d8 20 00 00       	call   13100 <_KeStallExecutionProcessor@4>

    /* Read NIC response */
    NdisRawReadPortUchar(address + PG0_CR, &Tmp);
   11028:	53                   	push   %ebx
   11029:	e8 e2 20 00 00       	call   13110 <_READ_PORT_UCHAR@4>

    if ((Tmp == (CR_RD2 | CR_STP)) || (Tmp == (CR_RD2 | CR_STP | CR_STA)))
   1102e:	83 c4 0c             	add    $0xc,%esp
   11031:	3c 21                	cmp    $0x21,%al
   11033:	0f 94 c2             	sete   %dl
   11036:	3c 23                	cmp    $0x23,%al
        return TRUE;
    else
        return FALSE;
}
   11038:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1103b:	0f 94 c0             	sete   %al
   1103e:	09 d0                	or     %edx,%eax
   11040:	c9                   	leave  
   11041:	a8 01                	test   $0x1,%al
   11043:	0f 95 c0             	setne  %al
   11046:	25 ff 00 00 00       	and    $0xff,%eax
   1104b:	c3                   	ret    
   1104c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011050 <_NICCheck>:


BOOLEAN NICCheck(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Tests for a NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     TRUE if NIC is believed to be present, FALSE if not
 */
{
   11050:	55                   	push   %ebp
   11051:	89 e5                	mov    %esp,%ebp
   11053:	56                   	push   %esi
   11054:	53                   	push   %ebx
   11055:	8b 75 08             	mov    0x8(%ebp),%esi
    int i; 

    NDIS_DbgPrint(MAX_TRACE, ("Called\n"));

    /* first try the supplied value */
    if(ProbeAddressForNIC(Adapter->IoBaseAddress))
   11058:	83 ec 0c             	sub    $0xc,%esp
   1105b:	8b 46 58             	mov    0x58(%esi),%eax
   1105e:	50                   	push   %eax
   1105f:	e8 9c ff ff ff       	call   11000 <_ProbeAddressForNIC>
   11064:	83 c4 10             	add    $0x10,%esp
    {
        NDIS_DbgPrint(MIN_TRACE, ("Found adapter at 0x%x\n", Adapter->IoBaseAddress));
        return TRUE;
   11067:	ba 01 00 00 00       	mov    $0x1,%edx
   1106c:	84 c0                	test   %al,%al
   1106e:	75 35                	jne    110a5 <_NICCheck+0x55>
    }

    /* ok, no dice, time to probe */
    for(i = 0; ProbeAddressList[i]; i++)
   11070:	a1 00 40 01 00       	mov    0x14000,%eax
   11075:	31 db                	xor    %ebx,%ebx
   11077:	85 c0                	test   %eax,%eax
   11079:	74 28                	je     110a3 <_NICCheck+0x53>
   1107b:	90                   	nop    
   1107c:	8d 74 26 00          	lea    0x0(%esi),%esi
    {
        if(ProbeAddressForNIC(ProbeAddressList[i]))
   11080:	83 ec 0c             	sub    $0xc,%esp
   11083:	8b 0c 9d 00 40 01 00 	mov    0x14000(,%ebx,4),%ecx
   1108a:	51                   	push   %ecx
   1108b:	e8 70 ff ff ff       	call   11000 <_ProbeAddressForNIC>
   11090:	83 c4 10             	add    $0x10,%esp
   11093:	84 c0                	test   %al,%al
   11095:	75 17                	jne    110ae <_NICCheck+0x5e>
   11097:	43                   	inc    %ebx
   11098:	8b 14 9d 00 40 01 00 	mov    0x14000(,%ebx,4),%edx
   1109f:	85 d2                	test   %edx,%edx
   110a1:	75 dd                	jne    11080 <_NICCheck+0x30>
        {
            NDIS_DbgPrint(MIN_TRACE, ("Found adapter at address 0x%x\n", ProbeAddressList[i]));
            Adapter->IoBaseAddress = ProbeAddressList[i];
            return TRUE;
        }
    }

    NDIS_DbgPrint(MIN_TRACE,("Adapter NOT found!\n"));
    return FALSE;
   110a3:	31 d2                	xor    %edx,%edx
}
   110a5:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   110a8:	89 d0                	mov    %edx,%eax
   110aa:	5b                   	pop    %ebx
   110ab:	5e                   	pop    %esi
   110ac:	5d                   	pop    %ebp
   110ad:	c3                   	ret    
   110ae:	8b 04 9d 00 40 01 00 	mov    0x14000(,%ebx,4),%eax
   110b5:	ba 01 00 00 00       	mov    $0x1,%edx
   110ba:	89 46 58             	mov    %eax,0x58(%esi)
   110bd:	eb e6                	jmp    110a5 <_NICCheck+0x55>
   110bf:	90                   	nop    

000110c0 <_NICSetPhysicalAddress>:


BOOLEAN NICTestAddress(
    PNIC_ADAPTER Adapter,
    ULONG Address)
/*
 * FUNCTION: Tests if an address is writable
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     TRUE if the address is writable, FALSE if not
 */
{
    USHORT Data;
    USHORT Tmp;

    /* Read one word */
    NICReadDataAlign(Adapter, &Data, Address, 0x02);

    /* Alter it */
    Data ^= 0xFFFF;

    /* Write it back */
    NICWriteDataAlign(Adapter, Address, &Data, 0x02);

    /* Check if it has changed on the NIC */
    NICReadDataAlign(Adapter, &Tmp, Address, 0x02);

    return (Data == Tmp);
}


BOOLEAN NICTestRAM(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Finds out how much RAM a NIC has
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     TRUE if the RAM size was found, FALSE if not
 * NOTES:
 *     Start at 1KB and test for every 1KB up to 64KB
 */
{
    ULONG Base;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Locate RAM base address */
    for (Base = 0x0400; Base < 0x10000; Base += 0x0400) {
        if (NICTestAddress(Adapter, Base))
            break;
    }

    if (Base == 0x10000) {
        /* No RAM on this board */
        NDIS_DbgPrint(MIN_TRACE, ("No RAM found on board.\n"));
        return FALSE;
    }

    Adapter->RamBase = (PUCHAR)Base;

    /* Find RAM size */
    for (; Base < 0x10000; Base += 0x0400) {
        if (!NICTestAddress(Adapter, Base))
            break;
    }

    Adapter->RamSize = (UINT)(Base - (ULONG_PTR)Adapter->RamBase);

    NDIS_DbgPrint(MID_TRACE, ("RAM is at (0x%X). Size is (0x%X).\n",
        Adapter->RamBase, Adapter->RamSize));

    return TRUE;
}


VOID NICSetPhysicalAddress(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Initializes the physical address on the NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * NOTES:
 *     The physical address is taken from Adapter.
 *     The NIC is stopped by this operation
 */
{
   110c0:	55                   	push   %ebp
   110c1:	89 e5                	mov    %esp,%ebp
   110c3:	56                   	push   %esi
   110c4:	53                   	push   %ebx
   110c5:	8b 75 08             	mov    0x8(%ebp),%esi
    UINT i;

    /* Select page 1 */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE1);
   110c8:	53                   	push   %ebx
   110c9:	53                   	push   %ebx
   110ca:	6a 61                	push   $0x61
   110cc:	8b 4e 60             	mov    0x60(%esi),%ecx

    /* Initialize PAR - Physical Address Registers */
    for (i = 0; i < 0x06; i++)
   110cf:	31 db                	xor    %ebx,%ebx
   110d1:	51                   	push   %ecx
   110d2:	e8 19 20 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   110d7:	58                   	pop    %eax
   110d8:	5a                   	pop    %edx
   110d9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
        NdisRawWritePortUchar(Adapter->IOBase + PG1_PAR + i, Adapter->StationAddress[i]);
   110e0:	31 c0                	xor    %eax,%eax
   110e2:	51                   	push   %ecx
   110e3:	51                   	push   %ecx
   110e4:	8a 84 1e 86 00 00 00 	mov    0x86(%esi,%ebx,1),%al
   110eb:	50                   	push   %eax
   110ec:	8b 46 60             	mov    0x60(%esi),%eax
   110ef:	01 d8                	add    %ebx,%eax
   110f1:	43                   	inc    %ebx
   110f2:	40                   	inc    %eax
   110f3:	50                   	push   %eax
   110f4:	e8 f7 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   110f9:	83 fb 05             	cmp    $0x5,%ebx
   110fc:	58                   	pop    %eax
   110fd:	5a                   	pop    %edx
   110fe:	76 e0                	jbe    110e0 <_NICSetPhysicalAddress+0x20>

    /* Go back to page 0 */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE0);
   11100:	50                   	push   %eax
   11101:	50                   	push   %eax
   11102:	6a 21                	push   $0x21
   11104:	8b 46 60             	mov    0x60(%esi),%eax
   11107:	50                   	push   %eax
   11108:	e8 e3 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   1110d:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11110:	5b                   	pop    %ebx
   11111:	5e                   	pop    %esi
   11112:	5d                   	pop    %ebp
   11113:	c3                   	ret    
   11114:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1111a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011120 <_NICSetMulticastAddressMask>:
}


VOID NICSetMulticastAddressMask(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Initializes the multicast address mask on the NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * NOTES:
 *     The multicast address mask is taken from Adapter.
 *     The NIC is stopped by this operation
 */
{
   11120:	55                   	push   %ebp
   11121:	89 e5                	mov    %esp,%ebp
   11123:	56                   	push   %esi
   11124:	53                   	push   %ebx
   11125:	8b 75 08             	mov    0x8(%ebp),%esi
    UINT i;

    /* Select page 1 */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE1);
   11128:	53                   	push   %ebx
   11129:	53                   	push   %ebx
   1112a:	6a 61                	push   $0x61
   1112c:	8b 4e 60             	mov    0x60(%esi),%ecx

    /* Initialize MAR - Multicast Address Registers */
    for (i = 0; i < 0x08; i++)
   1112f:	31 db                	xor    %ebx,%ebx
   11131:	51                   	push   %ecx
   11132:	e8 b9 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11137:	58                   	pop    %eax
   11138:	5a                   	pop    %edx
   11139:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
        NdisRawWritePortUchar(Adapter->IOBase + PG1_MAR + i, Adapter->MulticastAddressMask[i]);
   11140:	31 c0                	xor    %eax,%eax
   11142:	51                   	push   %ecx
   11143:	51                   	push   %ecx
   11144:	8a 84 1e c0 00 00 00 	mov    0xc0(%esi,%ebx,1),%al
   1114b:	50                   	push   %eax
   1114c:	8b 46 60             	mov    0x60(%esi),%eax
   1114f:	01 d8                	add    %ebx,%eax
   11151:	43                   	inc    %ebx
   11152:	83 c0 08             	add    $0x8,%eax
   11155:	50                   	push   %eax
   11156:	e8 95 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   1115b:	83 fb 07             	cmp    $0x7,%ebx
   1115e:	58                   	pop    %eax
   1115f:	5a                   	pop    %edx
   11160:	76 de                	jbe    11140 <_NICSetMulticastAddressMask+0x20>

    /* Go back to page 0 */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE0);
   11162:	50                   	push   %eax
   11163:	50                   	push   %eax
   11164:	6a 21                	push   $0x21
   11166:	8b 76 60             	mov    0x60(%esi),%esi
   11169:	56                   	push   %esi
   1116a:	e8 81 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   1116f:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11172:	5b                   	pop    %ebx
   11173:	5e                   	pop    %esi
   11174:	5d                   	pop    %ebp
   11175:	c3                   	ret    
   11176:	8d 76 00             	lea    0x0(%esi),%esi
   11179:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011180 <_NICReadSAPROM>:
}


BOOLEAN NICReadSAPROM(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Reads the Station Address PROM data from the NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     TRUE if a the NIC is an NE2000
 * NOTES:
 *    This routine also determines if the NIC can support word mode transfers
 *    and if it does initializes the NIC for word mode.
 *    The station address in the adapter structure is initialized with
 *    the address from the SAPROM
 */
{
   11180:	55                   	push   %ebp
   11181:	89 e5                	mov    %esp,%ebp
   11183:	57                   	push   %edi
   11184:	56                   	push   %esi
   11185:	53                   	push   %ebx
   11186:	83 ec 34             	sub    $0x34,%esp
    UINT i;
    UCHAR Buffer[32];
    UCHAR WordLength;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Read Station Address PROM (SAPROM) which is 16 bytes at remote DMA address 0.
       Some cards double the data read which we must compensate for */

    /* Initialize RBCR0 and RBCR1 - Remote Byte Count Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, 0x20);
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, 0x00);

    /* Initialize RSAR0 and RSAR1 - Remote Start Address Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR0, 0x00);
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR1, 0x00);

    /* Select page 0, read and start the NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD0 | CR_PAGE0);

    /* Read one byte at a time */
    WordLength = 2; /* Assume a word is two bytes */
   11189:	bf 02 00 00 00       	mov    $0x2,%edi
   1118e:	8b 75 08             	mov    0x8(%ebp),%esi
    for (i = 0; i < 32; i += 2) {
   11191:	31 db                	xor    %ebx,%ebx
   11193:	6a 20                	push   $0x20
   11195:	8b 46 60             	mov    0x60(%esi),%eax
   11198:	83 c0 0a             	add    $0xa,%eax
   1119b:	50                   	push   %eax
   1119c:	e8 4f 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   111a1:	6a 00                	push   $0x0
   111a3:	8b 46 60             	mov    0x60(%esi),%eax
   111a6:	83 c0 0b             	add    $0xb,%eax
   111a9:	50                   	push   %eax
   111aa:	e8 41 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   111af:	6a 00                	push   $0x0
   111b1:	8b 46 60             	mov    0x60(%esi),%eax
   111b4:	83 c0 08             	add    $0x8,%eax
   111b7:	50                   	push   %eax
   111b8:	e8 33 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   111bd:	6a 00                	push   $0x0
   111bf:	8b 46 60             	mov    0x60(%esi),%eax
   111c2:	83 c0 09             	add    $0x9,%eax
   111c5:	50                   	push   %eax
   111c6:	e8 25 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   111cb:	6a 0a                	push   $0xa
   111cd:	8b 4e 60             	mov    0x60(%esi),%ecx
   111d0:	51                   	push   %ecx
   111d1:	e8 1a 1f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   111d6:	58                   	pop    %eax
   111d7:	5a                   	pop    %edx
        NdisRawReadPortUchar(Adapter->IOBase + NIC_DATA, &Buffer[i]);
   111d8:	83 ec 0c             	sub    $0xc,%esp
   111db:	8b 46 60             	mov    0x60(%esi),%eax
   111de:	83 c0 10             	add    $0x10,%eax
   111e1:	50                   	push   %eax
   111e2:	e8 29 1f 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   111e7:	88 44 2b c8          	mov    %al,0xffffffc8(%ebx,%ebp,1)
        NdisRawReadPortUchar(Adapter->IOBase + NIC_DATA, &Buffer[i + 1]);
   111eb:	8b 46 60             	mov    0x60(%esi),%eax
   111ee:	83 c0 10             	add    $0x10,%eax
   111f1:	50                   	push   %eax
   111f2:	e8 19 1f 00 00       	call   13110 <_READ_PORT_UCHAR@4>
		if (Buffer[i] != Buffer[i + 1])
   111f7:	83 c4 0c             	add    $0xc,%esp
   111fa:	88 44 1d c9          	mov    %al,0xffffffc9(%ebp,%ebx,1)
   111fe:	38 44 2b c8          	cmp    %al,0xffffffc8(%ebx,%ebp,1)
   11202:	74 05                	je     11209 <_NICReadSAPROM+0x89>
			WordLength = 1; /* A word is one byte long */
   11204:	bf 01 00 00 00       	mov    $0x1,%edi
   11209:	83 c3 02             	add    $0x2,%ebx
   1120c:	83 fb 1f             	cmp    $0x1f,%ebx
   1120f:	76 c7                	jbe    111d8 <_NICReadSAPROM+0x58>
	}

    /* If WordLength is 2 the data read before was doubled. We must compensate for this */
    if (WordLength == 2) {
   11211:	89 f8                	mov    %edi,%eax
   11213:	3c 02                	cmp    $0x2,%al
   11215:	74 0e                	je     11225 <_NICReadSAPROM+0xa5>
        NDIS_DbgPrint(MAX_TRACE,("NE2000 or compatible network adapter found.\n"));

        Adapter->WordMode = TRUE;

        /* Move the SAPROM data to the adapter object */
        for (i = 0; i < 16; i++)
            Adapter->SAPROM[i] = Buffer[i * 2];

        /* Copy the station address */
        NdisMoveMemory(
            (PVOID)&Adapter->StationAddress,
            (PVOID)&Adapter->SAPROM,
            DRIVER_LENGTH_OF_ADDRESS);

        /* Initialize DCR - Data Configuration Register (word mode/4 words FIFO) */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_DCR, DCR_WTS | DCR_LS | DCR_FT10);

        return TRUE;
    } else {
        NDIS_DbgPrint(MAX_TRACE, ("NE1000 or compatible network adapter found.\n"));

        Adapter->WordMode = FALSE;
   11217:	c6 46 64 00          	movb   $0x0,0x64(%esi)

        return FALSE;
   1121b:	31 c0                	xor    %eax,%eax
    }
}
   1121d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11220:	5b                   	pop    %ebx
   11221:	5e                   	pop    %esi
   11222:	5f                   	pop    %edi
   11223:	5d                   	pop    %ebp
   11224:	c3                   	ret    
   11225:	c6 46 64 01          	movb   $0x1,0x64(%esi)
   11229:	31 db                	xor    %ebx,%ebx
   1122b:	90                   	nop    
   1122c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11230:	8a 44 5d c8          	mov    0xffffffc8(%ebp,%ebx,2),%al
   11234:	88 44 1e 70          	mov    %al,0x70(%esi,%ebx,1)
   11238:	43                   	inc    %ebx
   11239:	83 fb 0f             	cmp    $0xf,%ebx
   1123c:	76 f2                	jbe    11230 <_NICReadSAPROM+0xb0>
   1123e:	8b 46 70             	mov    0x70(%esi),%eax
   11241:	89 86 86 00 00 00    	mov    %eax,0x86(%esi)
   11247:	66 8b 46 74          	mov    0x74(%esi),%ax
   1124b:	66 89 86 8a 00 00 00 	mov    %ax,0x8a(%esi)
   11252:	57                   	push   %edi
   11253:	57                   	push   %edi
   11254:	6a 49                	push   $0x49
   11256:	8b 46 60             	mov    0x60(%esi),%eax
   11259:	83 c0 0e             	add    $0xe,%eax
   1125c:	50                   	push   %eax
   1125d:	e8 8e 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11262:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11265:	b8 01 00 00 00       	mov    $0x1,%eax
   1126a:	5b                   	pop    %ebx
   1126b:	5e                   	pop    %esi
   1126c:	5f                   	pop    %edi
   1126d:	5d                   	pop    %ebp
   1126e:	c3                   	ret    
   1126f:	90                   	nop    

00011270 <_NICSetup>:


NDIS_STATUS NICInitialize(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Initializes a NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     Status of NIC initialization
 * NOTES:
 *     The NIC is put into loopback mode
 */
{
    UCHAR Tmp;

    NDIS_DbgPrint(MID_TRACE, ("Called.\n"));

    /* Reset the NIC */
    NdisRawReadPortUchar(Adapter->IOBase + NIC_RESET, &Tmp);

    /* Wait for 1.6ms */
    NdisStallExecution(1600);

    /* Write the value back  */
    NdisRawWritePortUchar(Adapter->IOBase + NIC_RESET, Tmp);

    /* Select page 0 and stop NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE0);
   
    /* Initialize DCR - Data Configuration Register (byte mode/8 bytes FIFO) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_DCR, DCR_LS | DCR_FT10);

    /* Clear RBCR0 and RBCR1 - Remote Byte Count Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, 0x00);
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, 0x00);

    /* Initialize RCR - Receive Configuration Register (monitor mode) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RCR, RCR_MON);

    /* Enter loopback mode (internal NIC module loopback) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_TCR, TCR_LOOP);

    /* Read the Station Address PROM */
    if (!NICReadSAPROM(Adapter))
        return NDIS_STATUS_ADAPTER_NOT_FOUND;

    NDIS_DbgPrint(MID_TRACE, ("Station address is (%02X %02X %02X %02X %02X %02X).\n",
        Adapter->StationAddress[0], Adapter->StationAddress[1],
        Adapter->StationAddress[2], Adapter->StationAddress[3],
        Adapter->StationAddress[4], Adapter->StationAddress[5]));

    /* Select page 0 and start NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2 | CR_PAGE0);

    /* Clear ISR - Interrupt Status Register */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, 0xFF);

    /* Find NIC RAM size */
    NICTestRAM(Adapter);

    return NDIS_STATUS_SUCCESS;
}


NDIS_STATUS NICSetup(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Sets up a NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     Status of operation
 * NOTES:
 *     The NIC is put into loopback mode
 */
{
   11270:	55                   	push   %ebp
   11271:	89 e5                	mov    %esp,%ebp
   11273:	53                   	push   %ebx
   11274:	50                   	push   %eax
   11275:	8b 5d 08             	mov    0x8(%ebp),%ebx
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    if (Adapter->WordMode ) {
   11278:	80 7b 64 00          	cmpb   $0x0,0x64(%ebx)
   1127c:	0f 84 25 01 00 00    	je     113a7 <_NICSetup+0x137>
        /* Initialize DCR - Data Configuration Register (word mode/4 words FIFO) */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_DCR, DCR_WTS | DCR_LS | DCR_FT10);
   11282:	50                   	push   %eax
   11283:	50                   	push   %eax
   11284:	6a 49                	push   $0x49
    } else {
        /* Initialize DCR - Data Configuration Register (byte mode/8 bytes FIFO) */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_DCR, DCR_LS | DCR_FT10);
   11286:	8b 43 60             	mov    0x60(%ebx),%eax
   11289:	83 c0 0e             	add    $0xe,%eax
   1128c:	50                   	push   %eax
   1128d:	e8 5e 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    }

    /* Clear RBCR0 and RBCR1 - Remote Byte Count Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, 0x00);
   11292:	6a 00                	push   $0x0
   11294:	8b 43 60             	mov    0x60(%ebx),%eax
   11297:	83 c0 0a             	add    $0xa,%eax
   1129a:	50                   	push   %eax
   1129b:	e8 50 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, 0x00);
   112a0:	6a 00                	push   $0x0
   112a2:	8b 43 60             	mov    0x60(%ebx),%eax
   112a5:	83 c0 0b             	add    $0xb,%eax
   112a8:	50                   	push   %eax
   112a9:	e8 42 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize RCR - Receive Configuration Register (monitor mode) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RCR, RCR_MON);
   112ae:	6a 20                	push   $0x20
   112b0:	8b 43 60             	mov    0x60(%ebx),%eax
   112b3:	83 c0 0c             	add    $0xc,%eax
   112b6:	50                   	push   %eax
   112b7:	e8 34 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Enter loopback mode (internal NIC module loopback) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_TCR, TCR_LOOP);
   112bc:	6a 02                	push   $0x2
   112be:	8b 43 60             	mov    0x60(%ebx),%eax
   112c1:	83 c0 0d             	add    $0xd,%eax
   112c4:	50                   	push   %eax
   112c5:	e8 26 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Set boundary page */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_BNRY, Adapter->NextPacket);
   112ca:	31 c0                	xor    %eax,%eax
   112cc:	8a 83 e0 01 00 00    	mov    0x1e0(%ebx),%al
   112d2:	50                   	push   %eax
   112d3:	8b 43 60             	mov    0x60(%ebx),%eax
   112d6:	83 c0 03             	add    $0x3,%eax
   112d9:	50                   	push   %eax
   112da:	e8 11 1e 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Set start page */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_PSTART, Adapter->PageStart);
   112df:	31 c0                	xor    %eax,%eax
   112e1:	8a 83 d4 01 00 00    	mov    0x1d4(%ebx),%al
   112e7:	50                   	push   %eax
   112e8:	8b 43 60             	mov    0x60(%ebx),%eax
   112eb:	40                   	inc    %eax
   112ec:	50                   	push   %eax
   112ed:	e8 fe 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Set stop page */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_PSTOP, Adapter->PageStop);
   112f2:	31 c0                	xor    %eax,%eax
   112f4:	8a 83 d8 01 00 00    	mov    0x1d8(%ebx),%al
   112fa:	50                   	push   %eax
   112fb:	8b 43 60             	mov    0x60(%ebx),%eax
   112fe:	83 c0 02             	add    $0x2,%eax
   11301:	50                   	push   %eax
   11302:	e8 e9 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Program our address on the NIC */
    NICSetPhysicalAddress(Adapter);
   11307:	51                   	push   %ecx
   11308:	53                   	push   %ebx
   11309:	e8 b2 fd ff ff       	call   110c0 <_NICSetPhysicalAddress>

    /* Program the multicast address mask on the NIC */
    NICSetMulticastAddressMask(Adapter);
   1130e:	89 1c 24             	mov    %ebx,(%esp)
   11311:	e8 0a fe ff ff       	call   11120 <_NICSetMulticastAddressMask>

    /* Select page 1 and stop NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE1);
   11316:	58                   	pop    %eax
   11317:	5a                   	pop    %edx
   11318:	6a 61                	push   $0x61
   1131a:	8b 43 60             	mov    0x60(%ebx),%eax
   1131d:	50                   	push   %eax
   1131e:	e8 cd 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize current page register */
    NdisRawWritePortUchar(Adapter->IOBase + PG1_CURR, Adapter->PageStart + 1);
   11323:	8a 83 d4 01 00 00    	mov    0x1d4(%ebx),%al
   11329:	40                   	inc    %eax
   1132a:	25 ff 00 00 00       	and    $0xff,%eax
   1132f:	50                   	push   %eax
   11330:	8b 43 60             	mov    0x60(%ebx),%eax
   11333:	83 c0 07             	add    $0x7,%eax
   11336:	50                   	push   %eax
   11337:	e8 b4 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Select page 0 and stop NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE0);
   1133c:	6a 21                	push   $0x21
   1133e:	8b 43 60             	mov    0x60(%ebx),%eax
   11341:	50                   	push   %eax
   11342:	e8 a9 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Clear ISR - Interrupt Status Register */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, 0xFF);
   11347:	68 ff 00 00 00       	push   $0xff
   1134c:	8b 43 60             	mov    0x60(%ebx),%eax
   1134f:	83 c0 07             	add    $0x7,%eax
   11352:	50                   	push   %eax
   11353:	e8 98 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize IMR - Interrupt Mask Register */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_IMR, Adapter->InterruptMask);
   11358:	31 c0                	xor    %eax,%eax
   1135a:	8a 83 c8 00 00 00    	mov    0xc8(%ebx),%al
   11360:	50                   	push   %eax
   11361:	8b 43 60             	mov    0x60(%ebx),%eax
   11364:	83 c0 0f             	add    $0xf,%eax
   11367:	50                   	push   %eax
   11368:	e8 83 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Select page 0 and start NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2 | CR_PAGE0);
   1136d:	6a 22                	push   $0x22
   1136f:	8b 43 60             	mov    0x60(%ebx),%eax
   11372:	50                   	push   %eax
   11373:	e8 78 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    Adapter->CurrentPage            = Adapter->PageStart + 1;
   11378:	8b 83 d4 01 00 00    	mov    0x1d4(%ebx),%eax
    Adapter->NextPacket             = Adapter->PageStart + 1;
    Adapter->BufferOverflow         = FALSE;
   1137e:	c6 83 e4 01 00 00 00 	movb   $0x0,0x1e4(%ebx)
   11385:	40                   	inc    %eax
    Adapter->ReceiveError           = FALSE;
   11386:	c6 83 e5 01 00 00 00 	movb   $0x0,0x1e5(%ebx)
   1138d:	89 83 dc 01 00 00    	mov    %eax,0x1dc(%ebx)
   11393:	89 83 e0 01 00 00    	mov    %eax,0x1e0(%ebx)
    Adapter->TransmitError          = FALSE;
   11399:	c6 83 e6 01 00 00 00 	movb   $0x0,0x1e6(%ebx)

    NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));

    return NDIS_STATUS_SUCCESS;
}
   113a0:	31 c0                	xor    %eax,%eax
   113a2:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   113a5:	c9                   	leave  
   113a6:	c3                   	ret    
   113a7:	50                   	push   %eax
   113a8:	50                   	push   %eax
   113a9:	6a 48                	push   $0x48
   113ab:	e9 d6 fe ff ff       	jmp    11286 <_NICSetup+0x16>

000113b0 <_NICStart>:


NDIS_STATUS NICStart(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Starts a NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     Status of operation
 */
{
   113b0:	55                   	push   %ebp
   113b1:	89 e5                	mov    %esp,%ebp
   113b3:	53                   	push   %ebx
   113b4:	83 ec 0c             	sub    $0xc,%esp
   113b7:	8b 5d 08             	mov    0x8(%ebp),%ebx
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Take NIC out of loopback mode */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_TCR, 0x00);
   113ba:	6a 00                	push   $0x0
   113bc:	8b 43 60             	mov    0x60(%ebx),%eax
   113bf:	83 c0 0d             	add    $0xd,%eax
   113c2:	50                   	push   %eax
   113c3:	e8 28 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize RCR - Receive Configuration Register (accept all) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RCR, RCR_AB | RCR_AM | RCR_PRO);
   113c8:	6a 1c                	push   $0x1c
   113ca:	8b 43 60             	mov    0x60(%ebx),%eax
   113cd:	83 c0 0c             	add    $0xc,%eax
   113d0:	50                   	push   %eax
   113d1:	e8 1a 1d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    return NDIS_STATUS_SUCCESS;
}
   113d6:	31 c0                	xor    %eax,%eax
   113d8:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   113db:	c9                   	leave  
   113dc:	c3                   	ret    
   113dd:	8d 76 00             	lea    0x0(%esi),%esi

000113e0 <_NICStop>:


NDIS_STATUS NICStop(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Stops a NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     Status of operation
 */
{
   113e0:	55                   	push   %ebp
   113e1:	89 e5                	mov    %esp,%ebp
   113e3:	56                   	push   %esi
   113e4:	53                   	push   %ebx
   113e5:	8b 75 08             	mov    0x8(%ebp),%esi
    UCHAR Tmp;
    UINT i;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Select page 0 and stop NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE0);
   113e8:	53                   	push   %ebx
   113e9:	53                   	push   %ebx
   113ea:	6a 21                	push   $0x21
   113ec:	8b 4e 60             	mov    0x60(%esi),%ecx

    /* Clear Remote Byte Count Register so ISR_RST will be set */
    NdisRawWritePortUchar( Adapter->IOBase + PG0_RBCR0, 0x00);
    NdisRawWritePortUchar( Adapter->IOBase + PG0_RBCR0, 0x00);

    /* Wait for ISR_RST to be set, but timeout after 2ms */
    for (i = 0; i < 4; i++) {
   113ef:	31 db                	xor    %ebx,%ebx
   113f1:	51                   	push   %ecx
   113f2:	e8 f9 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   113f7:	6a 00                	push   $0x0
   113f9:	8b 46 60             	mov    0x60(%esi),%eax
   113fc:	83 c0 0a             	add    $0xa,%eax
   113ff:	50                   	push   %eax
   11400:	e8 eb 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11405:	6a 00                	push   $0x0
   11407:	8b 46 60             	mov    0x60(%esi),%eax
   1140a:	83 c0 0a             	add    $0xa,%eax
   1140d:	50                   	push   %eax
   1140e:	e8 dd 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11413:	58                   	pop    %eax
   11414:	5a                   	pop    %edx
        NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &Tmp);
   11415:	83 ec 0c             	sub    $0xc,%esp
   11418:	8b 46 60             	mov    0x60(%esi),%eax
   1141b:	83 c0 07             	add    $0x7,%eax
   1141e:	50                   	push   %eax
   1141f:	e8 ec 1c 00 00       	call   13110 <_READ_PORT_UCHAR@4>
        if (Tmp & ISR_RST)
   11424:	83 c4 0c             	add    $0xc,%esp
   11427:	84 c0                	test   %al,%al
   11429:	78 16                	js     11441 <_NICStop+0x61>
            break;

        NdisStallExecution(500);
   1142b:	83 ec 0c             	sub    $0xc,%esp
   1142e:	43                   	inc    %ebx
   1142f:	68 f4 01 00 00       	push   $0x1f4
   11434:	e8 c7 1c 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   11439:	83 c4 0c             	add    $0xc,%esp
   1143c:	83 fb 03             	cmp    $0x3,%ebx
   1143f:	76 d4                	jbe    11415 <_NICStop+0x35>
    }

#ifdef DBG
    if (i == 4)
        NDIS_DbgPrint(MIN_TRACE, ("NIC was not reset after 2ms.\n"));
#endif

    /* Initialize RCR - Receive Configuration Register (monitor mode) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RCR, RCR_MON);
   11441:	50                   	push   %eax
   11442:	50                   	push   %eax
   11443:	6a 20                	push   $0x20
   11445:	8b 46 60             	mov    0x60(%esi),%eax
   11448:	83 c0 0c             	add    $0xc,%eax
   1144b:	50                   	push   %eax
   1144c:	e8 9f 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize TCR - Transmit Configuration Register (loopback mode) */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_TCR, TCR_LOOP);
   11451:	6a 02                	push   $0x2
   11453:	8b 46 60             	mov    0x60(%esi),%eax
   11456:	83 c0 0d             	add    $0xd,%eax
   11459:	50                   	push   %eax
   1145a:	e8 91 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Start NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2);
   1145f:	6a 22                	push   $0x22
   11461:	8b 46 60             	mov    0x60(%esi),%eax
   11464:	50                   	push   %eax
   11465:	e8 86 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    return NDIS_STATUS_SUCCESS;
}
   1146a:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1146d:	31 c0                	xor    %eax,%eax
   1146f:	5b                   	pop    %ebx
   11470:	5e                   	pop    %esi
   11471:	5d                   	pop    %ebp
   11472:	c3                   	ret    
   11473:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11479:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011480 <_NICReset>:


NDIS_STATUS NICReset(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Resets a NIC
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * RETURNS:
 *     Status of operation
 */
{
   11480:	55                   	push   %ebp
   11481:	89 e5                	mov    %esp,%ebp
   11483:	56                   	push   %esi
   11484:	53                   	push   %ebx
    UCHAR Tmp;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Stop the NIC */
    NICStop(Adapter);
   11485:	83 ec 0c             	sub    $0xc,%esp
   11488:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1148b:	53                   	push   %ebx
   1148c:	e8 4f ff ff ff       	call   113e0 <_NICStop>

    /* Reset the NIC */
    NdisRawReadPortUchar(Adapter->IOBase + NIC_RESET, &Tmp);
   11491:	8b 43 60             	mov    0x60(%ebx),%eax
   11494:	83 c0 1f             	add    $0x1f,%eax
   11497:	89 04 24             	mov    %eax,(%esp)
   1149a:	e8 71 1c 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   1149f:	89 c6                	mov    %eax,%esi

    /* Wait for 1.6ms */
    NdisStallExecution(1600);
   114a1:	68 40 06 00 00       	push   $0x640
   114a6:	e8 55 1c 00 00       	call   13100 <_KeStallExecutionProcessor@4>

    /* Write the value back  */
    NdisRawWritePortUchar(Adapter->IOBase + NIC_RESET, Tmp);
   114ab:	89 f0                	mov    %esi,%eax
   114ad:	25 ff 00 00 00       	and    $0xff,%eax
   114b2:	89 04 24             	mov    %eax,(%esp)
   114b5:	8b 43 60             	mov    0x60(%ebx),%eax
   114b8:	83 c0 1f             	add    $0x1f,%eax
   114bb:	50                   	push   %eax
   114bc:	e8 2f 1c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Restart the NIC */
    NICStart(Adapter);
   114c1:	56                   	push   %esi
   114c2:	53                   	push   %ebx
   114c3:	e8 e8 fe ff ff       	call   113b0 <_NICStart>

    return NDIS_STATUS_SUCCESS;
}
   114c8:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   114cb:	31 c0                	xor    %eax,%eax
   114cd:	5b                   	pop    %ebx
   114ce:	5e                   	pop    %esi
   114cf:	5d                   	pop    %ebp
   114d0:	c3                   	ret    
   114d1:	eb 0d                	jmp    114e0 <_NICStartTransmit>
   114d3:	90                   	nop    
   114d4:	90                   	nop    
   114d5:	90                   	nop    
   114d6:	90                   	nop    
   114d7:	90                   	nop    
   114d8:	90                   	nop    
   114d9:	90                   	nop    
   114da:	90                   	nop    
   114db:	90                   	nop    
   114dc:	90                   	nop    
   114dd:	90                   	nop    
   114de:	90                   	nop    
   114df:	90                   	nop    

000114e0 <_NICStartTransmit>:


VOID NICStartTransmit(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Starts transmitting a packet
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   114e0:	55                   	push   %ebp
   114e1:	89 e5                	mov    %esp,%ebp
   114e3:	56                   	push   %esi
   114e4:	53                   	push   %ebx
   114e5:	8b 75 08             	mov    0x8(%ebp),%esi
    UINT Length;
	UCHAR FrameStart;
    UCHAR Tmp;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

	//FrameStart = Adapter->TXStart + Adapter->TXCurrent * DRIVER_BLOCK_SIZE;
	//FrameStart = Adapter->TXStart;
	FrameStart = (UCHAR)(Adapter->TXStart + (UCHAR)(Adapter->TXCurrent * BUFFERS_PER_TX_BUF));

    /* Set start of frame */
    NdisRawReadPortUchar(Adapter->IOBase + PG0_TPSR, &Tmp);
   114e8:	83 ec 0c             	sub    $0xc,%esp
   114eb:	8b 46 60             	mov    0x60(%esi),%eax
   114ee:	8b 9e 34 02 00 00    	mov    0x234(%esi),%ebx
   114f4:	83 c0 04             	add    $0x4,%eax
   114f7:	02 9e f4 01 00 00    	add    0x1f4(%esi),%bl
   114fd:	50                   	push   %eax
   114fe:	e8 0d 1c 00 00       	call   13110 <_READ_PORT_UCHAR@4>
//    NdisRawWritePortUchar(Adapter->IOBase + PG0_TPSR,
//        Adapter->TXStart + Adapter->TXCurrent * DRIVER_BLOCK_SIZE);

    NdisRawWritePortUchar(Adapter->IOBase + PG0_TPSR, FrameStart);
   11503:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   11509:	89 1c 24             	mov    %ebx,(%esp)
   1150c:	8b 46 60             	mov    0x60(%esi),%eax
   1150f:	83 c0 04             	add    $0x4,%eax
   11512:	50                   	push   %eax
   11513:	e8 d8 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    //NDIS_DbgPrint(MID_TRACE, ("Setting start of frame to (%d).\n", FrameStart));

    /* Set length of frame */
    Length = Adapter->TXSize[Adapter->TXCurrent];
   11518:	8b 86 34 02 00 00    	mov    0x234(%esi),%eax
   1151e:	8b 9c 86 04 02 00 00 	mov    0x204(%esi,%eax,4),%ebx
    NdisRawWritePortUchar(Adapter->IOBase + PG0_TBCR0, Length & 0xFF);
   11525:	31 c0                	xor    %eax,%eax
   11527:	88 d8                	mov    %bl,%al
   11529:	50                   	push   %eax
   1152a:	8b 46 60             	mov    0x60(%esi),%eax
   1152d:	83 c0 05             	add    $0x5,%eax
   11530:	50                   	push   %eax
   11531:	e8 ba 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    NdisRawWritePortUchar(Adapter->IOBase + PG0_TBCR1, Length >> 8);
   11536:	0f b6 df             	movzbl %bh,%ebx
   11539:	53                   	push   %ebx
   1153a:	8b 46 60             	mov    0x60(%esi),%eax
   1153d:	83 c0 06             	add    $0x6,%eax
   11540:	50                   	push   %eax
   11541:	e8 aa 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Start transmitting */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_TXP | CR_RD2);
   11546:	6a 26                	push   $0x26
   11548:	8b 46 60             	mov    0x60(%esi),%eax
   1154b:	50                   	push   %eax
   1154c:	e8 9f 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11551:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11554:	5b                   	pop    %ebx
   11555:	5e                   	pop    %esi
   11556:	5d                   	pop    %ebp
   11557:	c3                   	ret    
   11558:	90                   	nop    
   11559:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011560 <_NICSetBoundaryPage>:

    NDIS_DbgPrint(MID_TRACE, ("Transmitting. FrameStart (%d)  TXCurrent (%d)  TXStart (%d)  Length (%d).\n\n", 
		FrameStart,
        Adapter->TXCurrent,
		Adapter->TXStart,
        Length));

}


VOID NICSetBoundaryPage(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Sets the boundary page on the adapter to be one less than NextPacket
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   11560:	55                   	push   %ebp
   11561:	89 e5                	mov    %esp,%ebp
   11563:	50                   	push   %eax
   11564:	50                   	push   %eax
   11565:	8b 55 08             	mov    0x8(%ebp),%edx
    if (Adapter->NextPacket == Adapter->PageStart) {
   11568:	8b 82 e0 01 00 00    	mov    0x1e0(%edx),%eax
   1156e:	3b 82 d4 01 00 00    	cmp    0x1d4(%edx),%eax
   11574:	74 1a                	je     11590 <_NICSetBoundaryPage+0x30>
        NdisRawWritePortUchar(Adapter->IOBase + PG0_BNRY,
            (UCHAR)(Adapter->PageStop - 1));
    } else {
        NdisRawWritePortUchar(Adapter->IOBase + PG0_BNRY,
   11576:	48                   	dec    %eax
   11577:	25 ff 00 00 00       	and    $0xff,%eax
   1157c:	51                   	push   %ecx
   1157d:	51                   	push   %ecx
   1157e:	50                   	push   %eax
   1157f:	8b 42 60             	mov    0x60(%edx),%eax
   11582:	83 c0 03             	add    $0x3,%eax
   11585:	50                   	push   %eax
   11586:	e8 65 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   1158b:	58                   	pop    %eax
   1158c:	5a                   	pop    %edx
            (UCHAR)(Adapter->NextPacket - 1));
    }
}
   1158d:	c9                   	leave  
   1158e:	c3                   	ret    
   1158f:	90                   	nop    
   11590:	50                   	push   %eax
   11591:	50                   	push   %eax
   11592:	8a 82 d8 01 00 00    	mov    0x1d8(%edx),%al
   11598:	48                   	dec    %eax
   11599:	25 ff 00 00 00       	and    $0xff,%eax
   1159e:	50                   	push   %eax
   1159f:	8b 42 60             	mov    0x60(%edx),%eax
   115a2:	83 c0 03             	add    $0x3,%eax
   115a5:	50                   	push   %eax
   115a6:	e8 45 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   115ab:	58                   	pop    %eax
   115ac:	5a                   	pop    %edx
   115ad:	c9                   	leave  
   115ae:	c3                   	ret    
   115af:	90                   	nop    

000115b0 <_NICGetCurrentPage>:


VOID NICGetCurrentPage(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Retrieves the current page from the adapter
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   115b0:	55                   	push   %ebp
   115b1:	89 e5                	mov    %esp,%ebp
   115b3:	56                   	push   %esi
   115b4:	53                   	push   %ebx
    UCHAR Current;

    /* Select page 1 */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2 | CR_PAGE1);
   115b5:	50                   	push   %eax
   115b6:	8b 5d 08             	mov    0x8(%ebp),%ebx
   115b9:	50                   	push   %eax
   115ba:	6a 62                	push   $0x62
   115bc:	8b 43 60             	mov    0x60(%ebx),%eax
   115bf:	50                   	push   %eax
   115c0:	e8 2b 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Read current page */
    NdisRawReadPortUchar(Adapter->IOBase + PG1_CURR, &Current);
   115c5:	50                   	push   %eax
   115c6:	8b 43 60             	mov    0x60(%ebx),%eax
   115c9:	83 c0 07             	add    $0x7,%eax
   115cc:	50                   	push   %eax
   115cd:	e8 3e 1b 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   115d2:	89 c6                	mov    %eax,%esi

    /* Select page 0 */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2 | CR_PAGE0);
   115d4:	c7 04 24 22 00 00 00 	movl   $0x22,(%esp)
   115db:	8b 43 60             	mov    0x60(%ebx),%eax
   115de:	50                   	push   %eax
   115df:	e8 0c 1b 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    Adapter->CurrentPage = Current;
   115e4:	89 f0                	mov    %esi,%eax
   115e6:	25 ff 00 00 00       	and    $0xff,%eax
   115eb:	89 83 dc 01 00 00    	mov    %eax,0x1dc(%ebx)
   115f1:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   115f4:	5b                   	pop    %ebx
   115f5:	5e                   	pop    %esi
   115f6:	5d                   	pop    %ebp
   115f7:	c3                   	ret    
   115f8:	90                   	nop    
   115f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011600 <_NICUpdateCounters>:
}


VOID NICUpdateCounters(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Updates counters
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   11600:	55                   	push   %ebp
   11601:	89 e5                	mov    %esp,%ebp
   11603:	53                   	push   %ebx
   11604:	83 ec 10             	sub    $0x10,%esp
   11607:	8b 5d 08             	mov    0x8(%ebp),%ebx
    UCHAR Tmp;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    NdisRawReadPortUchar(Adapter->IOBase + PG0_CNTR0, &Tmp);
   1160a:	8b 43 60             	mov    0x60(%ebx),%eax
   1160d:	83 c0 0d             	add    $0xd,%eax
   11610:	50                   	push   %eax
   11611:	e8 fa 1a 00 00       	call   13110 <_READ_PORT_UCHAR@4>
    Adapter->FrameAlignmentErrors += Tmp;
   11616:	8b 93 40 02 00 00    	mov    0x240(%ebx),%edx
   1161c:	25 ff 00 00 00       	and    $0xff,%eax
   11621:	01 c2                	add    %eax,%edx

    NdisRawReadPortUchar(Adapter->IOBase + PG0_CNTR1, &Tmp);
   11623:	8b 43 60             	mov    0x60(%ebx),%eax
   11626:	89 93 40 02 00 00    	mov    %edx,0x240(%ebx)
   1162c:	83 c0 0e             	add    $0xe,%eax
   1162f:	50                   	push   %eax
   11630:	e8 db 1a 00 00       	call   13110 <_READ_PORT_UCHAR@4>
    Adapter->CrcErrors += Tmp;
   11635:	8b 8b 44 02 00 00    	mov    0x244(%ebx),%ecx
   1163b:	25 ff 00 00 00       	and    $0xff,%eax
   11640:	01 c1                	add    %eax,%ecx

    NdisRawReadPortUchar(Adapter->IOBase + PG0_CNTR2, &Tmp);
   11642:	8b 43 60             	mov    0x60(%ebx),%eax
   11645:	89 8b 44 02 00 00    	mov    %ecx,0x244(%ebx)
   1164b:	83 c0 0f             	add    $0xf,%eax
   1164e:	50                   	push   %eax
   1164f:	e8 bc 1a 00 00       	call   13110 <_READ_PORT_UCHAR@4>
    Adapter->MissedPackets += Tmp;
   11654:	8b 93 48 02 00 00    	mov    0x248(%ebx),%edx
   1165a:	25 ff 00 00 00       	and    $0xff,%eax
   1165f:	01 c2                	add    %eax,%edx
   11661:	89 93 48 02 00 00    	mov    %edx,0x248(%ebx)
   11667:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1166a:	c9                   	leave  
   1166b:	c3                   	ret    
   1166c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011670 <_NICReadDataAlign>:
}


VOID NICReadDataAlign(
    PNIC_ADAPTER Adapter,
    PUSHORT Target,
    ULONG_PTR Source,
    USHORT Length)
/*
 * FUNCTION: Copies data from a NIC's RAM into a buffer
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 *     Target  = Pointer to buffer to copy data into (in host memory)
 *     Source  = Offset into NIC's RAM (must be an even number)
 *     Length  = Number of bytes to copy from NIC's RAM (must be an even number)
 */
{
   11670:	55                   	push   %ebp
   11671:	89 e5                	mov    %esp,%ebp
   11673:	57                   	push   %edi
   11674:	56                   	push   %esi
   11675:	53                   	push   %ebx
   11676:	83 ec 14             	sub    $0x14,%esp
   11679:	8b 75 08             	mov    0x8(%ebp),%esi
   1167c:	8b 7d 10             	mov    0x10(%ebp),%edi
    UCHAR Tmp;
    USHORT Count;

    Count = Length;

    /* Select page 0 and start the NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2 | CR_PAGE0);
   1167f:	6a 22                	push   $0x22
   11681:	8b 5d 14             	mov    0x14(%ebp),%ebx
   11684:	8b 46 60             	mov    0x60(%esi),%eax
   11687:	50                   	push   %eax
   11688:	e8 63 1a 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize RSAR0 and RSAR1 - Remote Start Address Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR0, (UCHAR)(Source & 0xFF));
   1168d:	89 f8                	mov    %edi,%eax
   1168f:	25 ff 00 00 00       	and    $0xff,%eax
   11694:	50                   	push   %eax
   11695:	8b 46 60             	mov    0x60(%esi),%eax
   11698:	83 c0 08             	add    $0x8,%eax
   1169b:	50                   	push   %eax
   1169c:	e8 4f 1a 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR1, (UCHAR)(Source >> 8));
   116a1:	89 fa                	mov    %edi,%edx
   116a3:	0f b6 c6             	movzbl %dh,%eax
   116a6:	50                   	push   %eax
   116a7:	8b 46 60             	mov    0x60(%esi),%eax
   116aa:	83 c0 09             	add    $0x9,%eax
   116ad:	50                   	push   %eax
   116ae:	e8 3d 1a 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize RBCR0 and RBCR1 - Remote Byte Count Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, (UCHAR)(Count & 0xFF));
   116b3:	31 c0                	xor    %eax,%eax
   116b5:	88 d8                	mov    %bl,%al
   116b7:	50                   	push   %eax
   116b8:	8b 46 60             	mov    0x60(%esi),%eax
   116bb:	83 c0 0a             	add    $0xa,%eax
   116be:	50                   	push   %eax
   116bf:	e8 2c 1a 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, (UCHAR)(Count >> 8));
   116c4:	0f b6 c7             	movzbl %bh,%eax
   116c7:	50                   	push   %eax
   116c8:	8b 46 60             	mov    0x60(%esi),%eax
   116cb:	83 c0 0b             	add    $0xb,%eax
   116ce:	50                   	push   %eax
   116cf:	e8 1c 1a 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Select page 0, read and start the NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD0 | CR_PAGE0);
   116d4:	6a 0a                	push   $0xa
   116d6:	8b 4e 60             	mov    0x60(%esi),%ecx
   116d9:	51                   	push   %ecx
   116da:	e8 11 1a 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    
    if (Adapter->WordMode)
   116df:	80 7e 64 00          	cmpb   $0x0,0x64(%esi)
   116e3:	58                   	pop    %eax
   116e4:	5a                   	pop    %edx
   116e5:	74 63                	je     1174a <_NICReadDataAlign+0xda>
        NdisRawReadPortBufferUshort(Adapter->IOBase + NIC_DATA, Target, Count >> 1);
   116e7:	66 d1 eb             	shr    %bx
   116ea:	50                   	push   %eax
   116eb:	89 d8                	mov    %ebx,%eax
   116ed:	25 ff ff 00 00       	and    $0xffff,%eax
   116f2:	50                   	push   %eax
   116f3:	8b 45 0c             	mov    0xc(%ebp),%eax
   116f6:	50                   	push   %eax
   116f7:	8b 46 60             	mov    0x60(%esi),%eax
   116fa:	83 c0 10             	add    $0x10,%eax
   116fd:	50                   	push   %eax
   116fe:	e8 1d 1a 00 00       	call   13120 <_READ_PORT_BUFFER_USHORT@12>
    else
        NdisRawReadPortBufferUchar(Adapter->IOBase + NIC_DATA, Target, Count);
   11703:	5b                   	pop    %ebx

    /* Wait for remote DMA to complete, but timeout after some time */
    for (Count = 0; Count < 0xFFFF; Count++) {
   11704:	31 db                	xor    %ebx,%ebx
   11706:	eb 14                	jmp    1171c <_NICReadDataAlign+0xac>
        NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &Tmp);
        if (Tmp & ISR_RDC)
            break;

        NdisStallExecution(4);
   11708:	83 ec 0c             	sub    $0xc,%esp
   1170b:	43                   	inc    %ebx
   1170c:	6a 04                	push   $0x4
   1170e:	e8 ed 19 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   11713:	83 c4 0c             	add    $0xc,%esp
   11716:	66 83 fb ff          	cmp    $0xffffffff,%bx
   1171a:	74 16                	je     11732 <_NICReadDataAlign+0xc2>
   1171c:	83 ec 0c             	sub    $0xc,%esp
   1171f:	8b 46 60             	mov    0x60(%esi),%eax
   11722:	83 c0 07             	add    $0x7,%eax
   11725:	50                   	push   %eax
   11726:	e8 e5 19 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   1172b:	83 c4 0c             	add    $0xc,%esp
   1172e:	a8 40                	test   $0x40,%al
   11730:	74 d6                	je     11708 <_NICReadDataAlign+0x98>
    }

#ifdef DBG
    if (Count == 0xFFFF)
        NDIS_DbgPrint(MIN_TRACE, ("Remote DMA did not complete.\n"));
#endif

    /* Clear remote DMA bit in ISR - Interrupt Status Register */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, ISR_RDC);
   11732:	51                   	push   %ecx
   11733:	51                   	push   %ecx
   11734:	6a 40                	push   $0x40
   11736:	8b 46 60             	mov    0x60(%esi),%eax
   11739:	83 c0 07             	add    $0x7,%eax
   1173c:	50                   	push   %eax
   1173d:	e8 ae 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11742:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11745:	5b                   	pop    %ebx
   11746:	5e                   	pop    %esi
   11747:	5f                   	pop    %edi
   11748:	5d                   	pop    %ebp
   11749:	c3                   	ret    
   1174a:	50                   	push   %eax
   1174b:	89 d8                	mov    %ebx,%eax
   1174d:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11750:	25 ff ff 00 00       	and    $0xffff,%eax
   11755:	50                   	push   %eax
   11756:	57                   	push   %edi
   11757:	8b 46 60             	mov    0x60(%esi),%eax
   1175a:	83 c0 10             	add    $0x10,%eax
   1175d:	50                   	push   %eax
   1175e:	e8 cd 19 00 00       	call   13130 <_READ_PORT_BUFFER_UCHAR@12>
   11763:	eb 9e                	jmp    11703 <_NICReadDataAlign+0x93>
   11765:	8d 74 26 00          	lea    0x0(%esi),%esi
   11769:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011770 <_NICWriteDataAlign>:
}


VOID NICWriteDataAlign(
    PNIC_ADAPTER Adapter,
    ULONG_PTR Target,
    PUSHORT Source,
    USHORT Length)
/*
 * FUNCTION: Copies data from a buffer into the NIC's RAM
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 *     Target  = Offset into NIC's RAM (must be an even number)
 *     Source  = Pointer to buffer to copy data from (in host memory)
 *     Length  = Number of bytes to copy from the buffer (must be an even number)
 */
{
   11770:	55                   	push   %ebp
   11771:	89 e5                	mov    %esp,%ebp
   11773:	57                   	push   %edi
   11774:	56                   	push   %esi
   11775:	53                   	push   %ebx
   11776:	83 ec 14             	sub    $0x14,%esp
    UCHAR Tmp;
    USHORT Count;

    /* Select page 0 and start the NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2 | CR_PAGE0);

    /* Handle read-before-write bug */

    /* Initialize RSAR0 and RSAR1 - Remote Start Address Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR0, (UCHAR)(Target & 0xFF));
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR1, (UCHAR)(Target >> 8));

    /* Initialize RBCR0 and RBCR1 - Remote Byte Count Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, 0x02);
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, 0x00);

    /* Read and start the NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD0 | CR_PAGE0);

    /* Read data */
    NdisRawReadPortUshort(Adapter->IOBase + NIC_DATA, &Count);

    /* Wait for remote DMA to complete, but timeout after some time */
    for (Count = 0; Count < 0xFFFF; Count++) {
   11779:	31 db                	xor    %ebx,%ebx
   1177b:	8b 75 08             	mov    0x8(%ebp),%esi
   1177e:	8b 45 14             	mov    0x14(%ebp),%eax
   11781:	6a 22                	push   $0x22
   11783:	66 89 45 f2          	mov    %ax,0xfffffff2(%ebp)
   11787:	8b 46 60             	mov    0x60(%esi),%eax
   1178a:	8b 7d 0c             	mov    0xc(%ebp),%edi
   1178d:	50                   	push   %eax
   1178e:	e8 5d 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11793:	89 f8                	mov    %edi,%eax
   11795:	25 ff 00 00 00       	and    $0xff,%eax
   1179a:	50                   	push   %eax
   1179b:	8b 46 60             	mov    0x60(%esi),%eax
   1179e:	83 c0 08             	add    $0x8,%eax
   117a1:	50                   	push   %eax
   117a2:	e8 49 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   117a7:	89 fa                	mov    %edi,%edx
   117a9:	0f b6 c6             	movzbl %dh,%eax
   117ac:	50                   	push   %eax
   117ad:	8b 46 60             	mov    0x60(%esi),%eax
   117b0:	83 c0 09             	add    $0x9,%eax
   117b3:	50                   	push   %eax
   117b4:	e8 37 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   117b9:	6a 02                	push   $0x2
   117bb:	8b 46 60             	mov    0x60(%esi),%eax
   117be:	83 c0 0a             	add    $0xa,%eax
   117c1:	50                   	push   %eax
   117c2:	e8 29 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   117c7:	6a 00                	push   $0x0
   117c9:	8b 46 60             	mov    0x60(%esi),%eax
   117cc:	83 c0 0b             	add    $0xb,%eax
   117cf:	50                   	push   %eax
   117d0:	e8 1b 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   117d5:	6a 0a                	push   $0xa
   117d7:	8b 46 60             	mov    0x60(%esi),%eax
   117da:	50                   	push   %eax
   117db:	e8 10 19 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   117e0:	50                   	push   %eax
   117e1:	8b 46 60             	mov    0x60(%esi),%eax
   117e4:	83 c0 10             	add    $0x10,%eax
   117e7:	50                   	push   %eax
   117e8:	e8 53 19 00 00       	call   13140 <_READ_PORT_USHORT@4>
   117ed:	83 c4 0c             	add    $0xc,%esp
        NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &Tmp);
   117f0:	83 ec 0c             	sub    $0xc,%esp
   117f3:	8b 46 60             	mov    0x60(%esi),%eax
   117f6:	83 c0 07             	add    $0x7,%eax
   117f9:	50                   	push   %eax
   117fa:	e8 11 19 00 00       	call   13110 <_READ_PORT_UCHAR@4>
        if (Tmp & ISR_RDC)
   117ff:	83 c4 0c             	add    $0xc,%esp
   11802:	a8 40                	test   $0x40,%al
   11804:	75 14                	jne    1181a <_NICWriteDataAlign+0xaa>
            break;

        NdisStallExecution(4);
   11806:	83 ec 0c             	sub    $0xc,%esp
   11809:	43                   	inc    %ebx
   1180a:	6a 04                	push   $0x4
   1180c:	e8 ef 18 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   11811:	83 c4 0c             	add    $0xc,%esp
   11814:	66 83 fb ff          	cmp    $0xffffffff,%bx
   11818:	75 d6                	jne    117f0 <_NICWriteDataAlign+0x80>
    }

#ifdef DBG
    if (Count == 0xFFFF)
        NDIS_DbgPrint(MIN_TRACE, ("Remote DMA did not complete.\n"));
#endif

    /* Clear remote DMA bit in ISR - Interrupt Status Register */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, ISR_RDC);
   1181a:	50                   	push   %eax
   1181b:	50                   	push   %eax
   1181c:	6a 40                	push   $0x40
   1181e:	8b 46 60             	mov    0x60(%esi),%eax
   11821:	83 c0 07             	add    $0x7,%eax
   11824:	50                   	push   %eax
   11825:	e8 c6 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>


    /* Now output some data */
    Count = Length;

    /* Initialize RSAR0 and RSAR1 - Remote Start Address Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR0, (UCHAR)(Target & 0xFF));
   1182a:	89 f8                	mov    %edi,%eax
   1182c:	66 8b 5d f2          	mov    0xfffffff2(%ebp),%bx
   11830:	25 ff 00 00 00       	and    $0xff,%eax
   11835:	50                   	push   %eax
   11836:	8b 46 60             	mov    0x60(%esi),%eax
   11839:	83 c0 08             	add    $0x8,%eax
   1183c:	50                   	push   %eax
   1183d:	e8 ae 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RSAR1, (UCHAR)(Target >> 8));
   11842:	89 fa                	mov    %edi,%edx
   11844:	0f b6 c6             	movzbl %dh,%eax
   11847:	50                   	push   %eax
   11848:	8b 46 60             	mov    0x60(%esi),%eax
   1184b:	83 c0 09             	add    $0x9,%eax
   1184e:	50                   	push   %eax
   1184f:	e8 9c 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Initialize RBCR0 and RBCR1 - Remote Byte Count Registers */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, (UCHAR)(Count & 0xFF));
   11854:	31 c0                	xor    %eax,%eax
   11856:	88 d8                	mov    %bl,%al
   11858:	50                   	push   %eax
   11859:	8b 46 60             	mov    0x60(%esi),%eax
   1185c:	83 c0 0a             	add    $0xa,%eax
   1185f:	50                   	push   %eax
   11860:	e8 8b 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, (UCHAR)(Count >> 8));
   11865:	0f b6 c7             	movzbl %bh,%eax
   11868:	50                   	push   %eax
   11869:	8b 46 60             	mov    0x60(%esi),%eax
   1186c:	83 c0 0b             	add    $0xb,%eax
   1186f:	50                   	push   %eax
   11870:	e8 7b 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>

    /* Write and start the NIC */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD1 | CR_PAGE0);
   11875:	6a 12                	push   $0x12
   11877:	8b 46 60             	mov    0x60(%esi),%eax
   1187a:	50                   	push   %eax
   1187b:	e8 70 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
    
    if (Adapter->WordMode)
   11880:	80 7e 64 00          	cmpb   $0x0,0x64(%esi)
   11884:	59                   	pop    %ecx
   11885:	5f                   	pop    %edi
   11886:	74 61                	je     118e9 <_NICWriteDataAlign+0x179>
        NdisRawWritePortBufferUshort(Adapter->IOBase + NIC_DATA, Source, Count >> 1);
   11888:	66 d1 eb             	shr    %bx
   1188b:	89 d8                	mov    %ebx,%eax
   1188d:	52                   	push   %edx
   1188e:	25 ff ff 00 00       	and    $0xffff,%eax
   11893:	50                   	push   %eax
   11894:	8b 45 10             	mov    0x10(%ebp),%eax
   11897:	50                   	push   %eax
   11898:	8b 46 60             	mov    0x60(%esi),%eax
   1189b:	83 c0 10             	add    $0x10,%eax
   1189e:	50                   	push   %eax
   1189f:	e8 ac 18 00 00       	call   13150 <_WRITE_PORT_BUFFER_USHORT@12>
    else
        NdisRawWritePortBufferUchar(Adapter->IOBase + NIC_DATA, Source, Count);
   118a4:	58                   	pop    %eax

    /* Wait for remote DMA to complete, but timeout after some time */
    for (Count = 0; Count < 0xFFFF; Count++) {
   118a5:	31 db                	xor    %ebx,%ebx
        NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &Tmp);
   118a7:	83 ec 0c             	sub    $0xc,%esp
   118aa:	8b 46 60             	mov    0x60(%esi),%eax
   118ad:	83 c0 07             	add    $0x7,%eax
   118b0:	50                   	push   %eax
   118b1:	e8 5a 18 00 00       	call   13110 <_READ_PORT_UCHAR@4>
        if (Tmp & ISR_RDC)
   118b6:	83 c4 0c             	add    $0xc,%esp
   118b9:	a8 40                	test   $0x40,%al
   118bb:	75 14                	jne    118d1 <_NICWriteDataAlign+0x161>
            break;

        NdisStallExecution(4);
   118bd:	83 ec 0c             	sub    $0xc,%esp
   118c0:	43                   	inc    %ebx
   118c1:	6a 04                	push   $0x4
   118c3:	e8 38 18 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   118c8:	83 c4 0c             	add    $0xc,%esp
   118cb:	66 83 fb ff          	cmp    $0xffffffff,%bx
   118cf:	75 d6                	jne    118a7 <_NICWriteDataAlign+0x137>
    }

#ifdef DBG
    if (Count == 0xFFFF)
        NDIS_DbgPrint(MIN_TRACE, ("Remote DMA did not complete.\n"));
#endif

    /* Clear remote DMA bit in ISR - Interrupt Status Register */
    NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, ISR_RDC);
   118d1:	50                   	push   %eax
   118d2:	50                   	push   %eax
   118d3:	6a 40                	push   $0x40
   118d5:	8b 46 60             	mov    0x60(%esi),%eax
   118d8:	83 c0 07             	add    $0x7,%eax
   118db:	50                   	push   %eax
   118dc:	e8 0f 18 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   118e1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   118e4:	5b                   	pop    %ebx
   118e5:	5e                   	pop    %esi
   118e6:	5f                   	pop    %edi
   118e7:	5d                   	pop    %ebp
   118e8:	c3                   	ret    
   118e9:	50                   	push   %eax
   118ea:	89 d8                	mov    %ebx,%eax
   118ec:	25 ff ff 00 00       	and    $0xffff,%eax
   118f1:	50                   	push   %eax
   118f2:	8b 45 10             	mov    0x10(%ebp),%eax
   118f5:	50                   	push   %eax
   118f6:	8b 46 60             	mov    0x60(%esi),%eax
   118f9:	83 c0 10             	add    $0x10,%eax
   118fc:	50                   	push   %eax
   118fd:	e8 5e 18 00 00       	call   13160 <_WRITE_PORT_BUFFER_UCHAR@12>
   11902:	eb a0                	jmp    118a4 <_NICWriteDataAlign+0x134>
   11904:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1190a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011910 <_NICTestAddress>:
   11910:	55                   	push   %ebp
   11911:	89 e5                	mov    %esp,%ebp
   11913:	57                   	push   %edi
   11914:	56                   	push   %esi
   11915:	53                   	push   %ebx
   11916:	83 ec 0c             	sub    $0xc,%esp
   11919:	8d 75 f2             	lea    0xfffffff2(%ebp),%esi
   1191c:	8b 7d 08             	mov    0x8(%ebp),%edi
   1191f:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11922:	6a 02                	push   $0x2
   11924:	53                   	push   %ebx
   11925:	56                   	push   %esi
   11926:	57                   	push   %edi
   11927:	e8 44 fd ff ff       	call   11670 <_NICReadDataAlign>
   1192c:	6a 02                	push   $0x2
   1192e:	56                   	push   %esi
   1192f:	53                   	push   %ebx
   11930:	57                   	push   %edi
   11931:	66 f7 55 f2          	notw   0xfffffff2(%ebp)
   11935:	e8 36 fe ff ff       	call   11770 <_NICWriteDataAlign>
   1193a:	83 c4 20             	add    $0x20,%esp
   1193d:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11940:	6a 02                	push   $0x2
   11942:	53                   	push   %ebx
   11943:	50                   	push   %eax
   11944:	57                   	push   %edi
   11945:	e8 26 fd ff ff       	call   11670 <_NICReadDataAlign>
   1194a:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1194d:	83 c4 10             	add    $0x10,%esp
   11950:	66 39 45 f2          	cmp    %ax,0xfffffff2(%ebp)
   11954:	0f 94 c0             	sete   %al
   11957:	25 ff 00 00 00       	and    $0xff,%eax
   1195c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1195f:	5b                   	pop    %ebx
   11960:	5e                   	pop    %esi
   11961:	5f                   	pop    %edi
   11962:	5d                   	pop    %ebp
   11963:	c3                   	ret    
   11964:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1196a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011970 <_NICTestRAM>:
   11970:	55                   	push   %ebp
   11971:	89 e5                	mov    %esp,%ebp
   11973:	56                   	push   %esi
   11974:	53                   	push   %ebx
   11975:	bb 00 04 00 00       	mov    $0x400,%ebx
   1197a:	8b 75 08             	mov    0x8(%ebp),%esi
   1197d:	eb 0f                	jmp    1198e <_NICTestRAM+0x1e>
   1197f:	90                   	nop    
   11980:	81 c3 00 04 00 00    	add    $0x400,%ebx
   11986:	81 fb ff ff 00 00    	cmp    $0xffff,%ebx
   1198c:	77 10                	ja     1199e <_NICTestRAM+0x2e>
   1198e:	52                   	push   %edx
   1198f:	52                   	push   %edx
   11990:	53                   	push   %ebx
   11991:	56                   	push   %esi
   11992:	e8 79 ff ff ff       	call   11910 <_NICTestAddress>
   11997:	83 c4 10             	add    $0x10,%esp
   1199a:	84 c0                	test   %al,%al
   1199c:	74 e2                	je     11980 <_NICTestRAM+0x10>
   1199e:	31 c0                	xor    %eax,%eax
   119a0:	81 fb 00 00 01 00    	cmp    $0x10000,%ebx
   119a6:	74 17                	je     119bf <_NICTestRAM+0x4f>
   119a8:	89 d8                	mov    %ebx,%eax
   119aa:	89 5e 68             	mov    %ebx,0x68(%esi)
   119ad:	81 fb ff ff 00 00    	cmp    $0xffff,%ebx
   119b3:	76 11                	jbe    119c6 <_NICTestRAM+0x56>
   119b5:	29 c3                	sub    %eax,%ebx
   119b7:	b8 01 00 00 00       	mov    $0x1,%eax
   119bc:	89 5e 6c             	mov    %ebx,0x6c(%esi)
   119bf:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   119c2:	5b                   	pop    %ebx
   119c3:	5e                   	pop    %esi
   119c4:	5d                   	pop    %ebp
   119c5:	c3                   	ret    
   119c6:	50                   	push   %eax
   119c7:	50                   	push   %eax
   119c8:	53                   	push   %ebx
   119c9:	56                   	push   %esi
   119ca:	e8 41 ff ff ff       	call   11910 <_NICTestAddress>
   119cf:	83 c4 10             	add    $0x10,%esp
   119d2:	84 c0                	test   %al,%al
   119d4:	74 0e                	je     119e4 <_NICTestRAM+0x74>
   119d6:	81 c3 00 04 00 00    	add    $0x400,%ebx
   119dc:	81 fb ff ff 00 00    	cmp    $0xffff,%ebx
   119e2:	76 e2                	jbe    119c6 <_NICTestRAM+0x56>
   119e4:	8b 46 68             	mov    0x68(%esi),%eax
   119e7:	eb cc                	jmp    119b5 <_NICTestRAM+0x45>
   119e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000119f0 <_NICInitialize>:
   119f0:	55                   	push   %ebp
   119f1:	89 e5                	mov    %esp,%ebp
   119f3:	56                   	push   %esi
   119f4:	53                   	push   %ebx
   119f5:	8b 75 08             	mov    0x8(%ebp),%esi
   119f8:	83 ec 0c             	sub    $0xc,%esp
   119fb:	8b 46 60             	mov    0x60(%esi),%eax
   119fe:	83 c0 1f             	add    $0x1f,%eax
   11a01:	50                   	push   %eax
   11a02:	e8 09 17 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   11a07:	88 c3                	mov    %al,%bl
   11a09:	68 40 06 00 00       	push   $0x640
   11a0e:	e8 ed 16 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   11a13:	31 c0                	xor    %eax,%eax
   11a15:	88 d8                	mov    %bl,%al
   11a17:	89 04 24             	mov    %eax,(%esp)
   11a1a:	8b 46 60             	mov    0x60(%esi),%eax
   11a1d:	83 c0 1f             	add    $0x1f,%eax
   11a20:	50                   	push   %eax
   11a21:	e8 ca 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a26:	6a 21                	push   $0x21
   11a28:	8b 46 60             	mov    0x60(%esi),%eax
   11a2b:	50                   	push   %eax
   11a2c:	e8 bf 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a31:	6a 48                	push   $0x48
   11a33:	8b 46 60             	mov    0x60(%esi),%eax
   11a36:	83 c0 0e             	add    $0xe,%eax
   11a39:	50                   	push   %eax
   11a3a:	e8 b1 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a3f:	6a 00                	push   $0x0
   11a41:	8b 46 60             	mov    0x60(%esi),%eax
   11a44:	83 c0 0a             	add    $0xa,%eax
   11a47:	50                   	push   %eax
   11a48:	e8 a3 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a4d:	6a 00                	push   $0x0
   11a4f:	8b 46 60             	mov    0x60(%esi),%eax
   11a52:	83 c0 0b             	add    $0xb,%eax
   11a55:	50                   	push   %eax
   11a56:	e8 95 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a5b:	6a 20                	push   $0x20
   11a5d:	8b 46 60             	mov    0x60(%esi),%eax
   11a60:	83 c0 0c             	add    $0xc,%eax
   11a63:	50                   	push   %eax
   11a64:	e8 87 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a69:	6a 02                	push   $0x2
   11a6b:	8b 46 60             	mov    0x60(%esi),%eax
   11a6e:	83 c0 0d             	add    $0xd,%eax
   11a71:	50                   	push   %eax
   11a72:	e8 79 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a77:	50                   	push   %eax
   11a78:	56                   	push   %esi
   11a79:	e8 02 f7 ff ff       	call   11180 <_NICReadSAPROM>
   11a7e:	83 c4 10             	add    $0x10,%esp
   11a81:	ba 06 00 01 c0       	mov    $0xc0010006,%edx
   11a86:	84 c0                	test   %al,%al
   11a88:	74 27                	je     11ab1 <_NICInitialize+0xc1>
   11a8a:	50                   	push   %eax
   11a8b:	50                   	push   %eax
   11a8c:	6a 22                	push   $0x22
   11a8e:	8b 5e 60             	mov    0x60(%esi),%ebx
   11a91:	53                   	push   %ebx
   11a92:	e8 59 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11a97:	68 ff 00 00 00       	push   $0xff
   11a9c:	8b 46 60             	mov    0x60(%esi),%eax
   11a9f:	83 c0 07             	add    $0x7,%eax
   11aa2:	50                   	push   %eax
   11aa3:	e8 48 16 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   11aa8:	51                   	push   %ecx
   11aa9:	56                   	push   %esi
   11aaa:	e8 c1 fe ff ff       	call   11970 <_NICTestRAM>
   11aaf:	31 d2                	xor    %edx,%edx
   11ab1:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11ab4:	89 d0                	mov    %edx,%eax
   11ab6:	5b                   	pop    %ebx
   11ab7:	5e                   	pop    %esi
   11ab8:	5d                   	pop    %ebp
   11ab9:	c3                   	ret    
   11aba:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011ac0 <_NICReadData>:
}


VOID NICReadData(
    PNIC_ADAPTER Adapter,
    PUCHAR Target,
    ULONG_PTR Source,
    USHORT Length)
/*
 * FUNCTION: Copies data from a NIC's RAM into a buffer
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 *     Target  = Pointer to buffer to copy data into (in host memory)
 *     Source  = Offset into NIC's RAM
 *     Length  = Number of bytes to copy from NIC's RAM
 */
{
   11ac0:	55                   	push   %ebp
   11ac1:	89 e5                	mov    %esp,%ebp
   11ac3:	57                   	push   %edi
   11ac4:	56                   	push   %esi
   11ac5:	53                   	push   %ebx
   11ac6:	83 ec 0c             	sub    $0xc,%esp
   11ac9:	8b 5d 10             	mov    0x10(%ebp),%ebx
   11acc:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11acf:	8b 75 14             	mov    0x14(%ebp),%esi
    USHORT Tmp;

    /* Avoid transfers to odd addresses */
    if (Source & 0x01) {
   11ad2:	f6 c3 01             	test   $0x1,%bl
   11ad5:	75 70                	jne    11b47 <_NICReadData+0x87>
        /* Transfer one word and use the MSB */
        NICReadDataAlign(Adapter, &Tmp, Source - 1, 0x02);
        *Target = (UCHAR)(Tmp >> 8);
        Source++;
        Target++;
        Length--;
    }

    if (Length & 0x01) {
   11ad7:	89 f0                	mov    %esi,%eax
   11ad9:	25 ff ff 00 00       	and    $0xffff,%eax
   11ade:	a8 01                	test   $0x1,%al
   11ae0:	74 4e                	je     11b30 <_NICReadData+0x70>
        /* Transfer as many words as we can without exceeding the buffer length */
        Tmp = Length & 0xFFFE;
   11ae2:	89 f0                	mov    %esi,%eax
   11ae4:	83 e0 fe             	and    $0xfffffffe,%eax
   11ae7:	66 89 45 f2          	mov    %ax,0xfffffff2(%ebp)
        NICReadDataAlign(Adapter, (PUSHORT)Target, Source, Tmp);
   11aeb:	25 ff ff 00 00       	and    $0xffff,%eax
   11af0:	50                   	push   %eax
   11af1:	53                   	push   %ebx
   11af2:	57                   	push   %edi
   11af3:	8b 45 08             	mov    0x8(%ebp),%eax
   11af6:	50                   	push   %eax
   11af7:	e8 74 fb ff ff       	call   11670 <_NICReadDataAlign>
        Source += Tmp;
   11afc:	66 8b 45 f2          	mov    0xfffffff2(%ebp),%ax
        Target  = (PUCHAR)((ULONG_PTR) Target + Tmp);

        /* Read one word and keep the LSB */
        NICReadDataAlign(Adapter, &Tmp, Source, 0x02);
   11b00:	6a 02                	push   $0x2
   11b02:	25 ff ff 00 00       	and    $0xffff,%eax
   11b07:	01 c3                	add    %eax,%ebx
   11b09:	01 c7                	add    %eax,%edi
   11b0b:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11b0e:	53                   	push   %ebx
   11b0f:	50                   	push   %eax
   11b10:	8b 45 08             	mov    0x8(%ebp),%eax
   11b13:	50                   	push   %eax
   11b14:	e8 57 fb ff ff       	call   11670 <_NICReadDataAlign>
        *Target = (UCHAR)(Tmp & 0x00FF);
   11b19:	66 8b 45 f2          	mov    0xfffffff2(%ebp),%ax
   11b1d:	83 c4 20             	add    $0x20,%esp
   11b20:	88 07                	mov    %al,(%edi)
    } else
        /* Transfer the rest of the data */
        NICReadDataAlign(Adapter, (PUSHORT)Target, Source, Length);
}
   11b22:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11b25:	5b                   	pop    %ebx
   11b26:	5e                   	pop    %esi
   11b27:	5f                   	pop    %edi
   11b28:	5d                   	pop    %ebp
   11b29:	c3                   	ret    
   11b2a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11b30:	50                   	push   %eax
   11b31:	53                   	push   %ebx
   11b32:	57                   	push   %edi
   11b33:	8b 45 08             	mov    0x8(%ebp),%eax
   11b36:	50                   	push   %eax
   11b37:	e8 34 fb ff ff       	call   11670 <_NICReadDataAlign>
   11b3c:	83 c4 10             	add    $0x10,%esp
   11b3f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11b42:	5b                   	pop    %ebx
   11b43:	5e                   	pop    %esi
   11b44:	5f                   	pop    %edi
   11b45:	5d                   	pop    %ebp
   11b46:	c3                   	ret    
   11b47:	8d 43 ff             	lea    0xffffffff(%ebx),%eax
   11b4a:	6a 02                	push   $0x2
   11b4c:	50                   	push   %eax
   11b4d:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11b50:	50                   	push   %eax
   11b51:	43                   	inc    %ebx
   11b52:	8b 55 08             	mov    0x8(%ebp),%edx
   11b55:	4e                   	dec    %esi
   11b56:	52                   	push   %edx
   11b57:	e8 14 fb ff ff       	call   11670 <_NICReadDataAlign>
   11b5c:	31 c0                	xor    %eax,%eax
   11b5e:	83 c4 10             	add    $0x10,%esp
   11b61:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11b64:	88 07                	mov    %al,(%edi)
   11b66:	47                   	inc    %edi
   11b67:	e9 6b ff ff ff       	jmp    11ad7 <_NICReadData+0x17>
   11b6c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011b70 <_NICWriteData>:


VOID NICWriteData(
    PNIC_ADAPTER Adapter,
    ULONG_PTR Target,
    PUCHAR Source,
    USHORT Length)
/*
 * FUNCTION: Copies data from a buffer into NIC's RAM
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 *     Target  = Offset into NIC's RAM to store data
 *     Source  = Pointer to buffer to copy data from (in host memory)
 *     Length  = Number of bytes to copy from buffer
 */
{
   11b70:	55                   	push   %ebp
   11b71:	89 e5                	mov    %esp,%ebp
   11b73:	57                   	push   %edi
   11b74:	56                   	push   %esi
   11b75:	53                   	push   %ebx
   11b76:	83 ec 0c             	sub    $0xc,%esp
   11b79:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11b7c:	8b 75 10             	mov    0x10(%ebp),%esi
   11b7f:	8b 5d 14             	mov    0x14(%ebp),%ebx
    USHORT Tmp;

    /* Avoid transfers to odd addresses */
    if (Target & 0x01) {
   11b82:	f7 c7 01 00 00 00    	test   $0x1,%edi
   11b88:	75 7e                	jne    11c08 <_NICWriteData+0x98>
        /* Read one word */
        NICReadDataAlign(Adapter, &Tmp, Target - 1, 0x02);

        /* Merge LSB with the new byte which become the new MSB */
        Tmp = (Tmp & 0x00FF) | (*Source << 8);

        /* Finally write the value back */
        NICWriteDataAlign(Adapter, Target - 1, &Tmp, 0x02);

        /* Update pointers */
        Source = (PUCHAR) ((ULONG_PTR) Source + 1);
        Target += 1;
        Length--;
    }

    if (Length & 0x01) {
   11b8a:	89 d8                	mov    %ebx,%eax
   11b8c:	25 ff ff 00 00       	and    $0xffff,%eax
   11b91:	a8 01                	test   $0x1,%al
   11b93:	74 5c                	je     11bf1 <_NICWriteData+0x81>
        /* Transfer as many words as we can without exceeding the transfer length */
        Tmp = Length & 0xFFFE;
   11b95:	89 d8                	mov    %ebx,%eax
   11b97:	83 e0 fe             	and    $0xfffffffe,%eax
   11b9a:	66 89 45 f2          	mov    %ax,0xfffffff2(%ebp)
        NICWriteDataAlign(Adapter, Target, (PUSHORT)Source, Tmp);
   11b9e:	25 ff ff 00 00       	and    $0xffff,%eax
   11ba3:	50                   	push   %eax
   11ba4:	56                   	push   %esi
   11ba5:	57                   	push   %edi
   11ba6:	8b 45 08             	mov    0x8(%ebp),%eax
   11ba9:	50                   	push   %eax
   11baa:	e8 c1 fb ff ff       	call   11770 <_NICWriteDataAlign>
        Source += Tmp;
   11baf:	66 8b 45 f2          	mov    0xfffffff2(%ebp),%ax
        Target += Tmp;

        /* Read one word */
        NICReadDataAlign(Adapter, &Tmp, Target, 0x02);
   11bb3:	6a 02                	push   $0x2
   11bb5:	25 ff ff 00 00       	and    $0xffff,%eax
   11bba:	01 c7                	add    %eax,%edi
   11bbc:	01 c6                	add    %eax,%esi
   11bbe:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11bc1:	57                   	push   %edi
   11bc2:	50                   	push   %eax
   11bc3:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11bc6:	53                   	push   %ebx
   11bc7:	e8 a4 fa ff ff       	call   11670 <_NICReadDataAlign>

        /* Merge MSB with the new byte which become the new LSB */
        Tmp = (Tmp & 0xFF00) | (*Source);
   11bcc:	31 c0                	xor    %eax,%eax

        /* Finally write the value back */
        NICWriteDataAlign(Adapter, Target, &Tmp, 0x02);
   11bce:	83 c4 20             	add    $0x20,%esp
   11bd1:	8a 06                	mov    (%esi),%al
   11bd3:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   11bd6:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11bd9:	6a 02                	push   $0x2
   11bdb:	50                   	push   %eax
    } else
        /* Transfer the rest of the data */
        NICWriteDataAlign(Adapter, Target, (PUSHORT)Source, Length);
   11bdc:	57                   	push   %edi
   11bdd:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11be0:	51                   	push   %ecx
   11be1:	e8 8a fb ff ff       	call   11770 <_NICWriteDataAlign>
   11be6:	83 c4 10             	add    $0x10,%esp
}
   11be9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11bec:	5b                   	pop    %ebx
   11bed:	5e                   	pop    %esi
   11bee:	5f                   	pop    %edi
   11bef:	5d                   	pop    %ebp
   11bf0:	c3                   	ret    
   11bf1:	50                   	push   %eax
   11bf2:	56                   	push   %esi
   11bf3:	57                   	push   %edi
   11bf4:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11bf7:	51                   	push   %ecx
   11bf8:	e8 73 fb ff ff       	call   11770 <_NICWriteDataAlign>
   11bfd:	83 c4 10             	add    $0x10,%esp
   11c00:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11c03:	5b                   	pop    %ebx
   11c04:	5e                   	pop    %esi
   11c05:	5f                   	pop    %edi
   11c06:	5d                   	pop    %ebp
   11c07:	c3                   	ret    
   11c08:	8d 47 ff             	lea    0xffffffff(%edi),%eax
   11c0b:	6a 02                	push   $0x2
   11c0d:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11c10:	50                   	push   %eax
   11c11:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11c14:	47                   	inc    %edi
   11c15:	50                   	push   %eax
   11c16:	4b                   	dec    %ebx
   11c17:	8b 45 08             	mov    0x8(%ebp),%eax
   11c1a:	50                   	push   %eax
   11c1b:	e8 50 fa ff ff       	call   11670 <_NICReadDataAlign>
   11c20:	31 c0                	xor    %eax,%eax
   11c22:	8a 06                	mov    (%esi),%al
   11c24:	46                   	inc    %esi
   11c25:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   11c28:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11c2b:	6a 02                	push   $0x2
   11c2d:	50                   	push   %eax
   11c2e:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11c31:	50                   	push   %eax
   11c32:	8b 45 08             	mov    0x8(%ebp),%eax
   11c35:	50                   	push   %eax
   11c36:	e8 35 fb ff ff       	call   11770 <_NICWriteDataAlign>
   11c3b:	83 c4 20             	add    $0x20,%esp
   11c3e:	e9 47 ff ff ff       	jmp    11b8a <_NICWriteData+0x1a>
   11c43:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11c49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011c50 <_NICIndicatePacket>:


VOID NICIndicatePacket(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Indicates a packet to the wrapper
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   11c50:	55                   	push   %ebp
   11c51:	89 e5                	mov    %esp,%ebp
   11c53:	57                   	push   %edi
   11c54:	56                   	push   %esi
   11c55:	53                   	push   %ebx
   11c56:	83 ec 0c             	sub    $0xc,%esp
   11c59:	8b 75 08             	mov    0x8(%ebp),%esi
    UINT IndicateLength;

    IndicateLength = (Adapter->PacketHeader.PacketLength <
   11c5c:	8b 9e d4 00 00 00    	mov    0xd4(%esi),%ebx
   11c62:	66 8b 86 ea 01 00 00 	mov    0x1ea(%esi),%ax
   11c69:	83 c3 0e             	add    $0xe,%ebx
   11c6c:	25 ff ff 00 00       	and    $0xffff,%eax
   11c71:	39 c3                	cmp    %eax,%ebx
   11c73:	76 02                	jbe    11c77 <_NICIndicatePacket+0x27>
   11c75:	89 c3                	mov    %eax,%ebx
        (Adapter->LookaheadSize + DRIVER_HEADER_SIZE))?
        (Adapter->PacketHeader.PacketLength) :
        (Adapter->LookaheadSize + DRIVER_HEADER_SIZE);

    /* Fill the lookahead buffer */
    NICReadData(Adapter,
   11c77:	8d 43 0e             	lea    0xe(%ebx),%eax
   11c7a:	8d be d8 00 00 00    	lea    0xd8(%esi),%edi
   11c80:	25 ff ff 00 00       	and    $0xffff,%eax
   11c85:	50                   	push   %eax
   11c86:	8b 86 ec 01 00 00    	mov    0x1ec(%esi),%eax
   11c8c:	83 c0 04             	add    $0x4,%eax
   11c8f:	50                   	push   %eax
   11c90:	57                   	push   %edi
   11c91:	56                   	push   %esi
   11c92:	e8 29 fe ff ff       	call   11ac0 <_NICReadData>
                (PUCHAR)&Adapter->Lookahead,
                Adapter->PacketOffset + sizeof(PACKET_HEADER),
                IndicateLength + DRIVER_HEADER_SIZE);

    NDIS_DbgPrint(MID_TRACE, ("Indicating (%d) bytes.\n", IndicateLength));
    DbgPrint("ne2000!NICIndicatePacket: Indicating (%d) bytes.\n", IndicateLength);
   11c97:	58                   	pop    %eax
   11c98:	5a                   	pop    %edx
   11c99:	53                   	push   %ebx
   11c9a:	68 00 50 01 00       	push   $0x15000
   11c9f:	e8 1c 14 00 00       	call   130c0 <_DbgPrint>

#if 0
    NDIS_DbgPrint(MAX_TRACE, ("FRAME:\n"));
    for (i = 0; i < (IndicateLength + 7) / 8; i++) {
        NDIS_DbgPrint(MAX_TRACE, ("%02X %02X %02X %02X %02X %02X %02X %02X\n",
            Adapter->Lookahead[i*8+0],
            Adapter->Lookahead[i*8+1],
            Adapter->Lookahead[i*8+2],
            Adapter->Lookahead[i*8+3],
            Adapter->Lookahead[i*8+4],
            Adapter->Lookahead[i*8+5],
            Adapter->Lookahead[i*8+6],
            Adapter->Lookahead[i*8+7]));
    }
#endif

    if (IndicateLength >= DRIVER_HEADER_SIZE) {
   11ca4:	83 c4 10             	add    $0x10,%esp
   11ca7:	83 fb 0d             	cmp    $0xd,%ebx
   11caa:	76 39                	jbe    11ce5 <_NICIndicatePacket+0x95>
	NDIS_DbgPrint(MAX_TRACE,("Adapter->MiniportAdapterHandle: %x\n",
				 Adapter->MiniportAdapterHandle));
        NdisMEthIndicateReceive(Adapter->MiniportAdapterHandle,
   11cac:	66 8b 86 ea 01 00 00 	mov    0x1ea(%esi),%ax
   11cb3:	8b 56 08             	mov    0x8(%esi),%edx
   11cb6:	25 ff ff 00 00       	and    $0xffff,%eax
   11cbb:	83 e8 0e             	sub    $0xe,%eax
   11cbe:	50                   	push   %eax
   11cbf:	8d 43 f2             	lea    0xfffffff2(%ebx),%eax
   11cc2:	50                   	push   %eax
   11cc3:	8d 86 e6 00 00 00    	lea    0xe6(%esi),%eax
   11cc9:	50                   	push   %eax
   11cca:	6a 0e                	push   $0xe
   11ccc:	57                   	push   %edi
   11ccd:	57                   	push   %edi
   11cce:	6a 00                	push   $0x0
   11cd0:	8b 8a d8 00 00 00    	mov    0xd8(%edx),%ecx
   11cd6:	51                   	push   %ecx
   11cd7:	ff 92 64 01 00 00    	call   *0x164(%edx)
                                NULL,
                                (PVOID)&Adapter->Lookahead,
                                DRIVER_HEADER_SIZE,
                                (PVOID)&Adapter->Lookahead[DRIVER_HEADER_SIZE],
                                IndicateLength - DRIVER_HEADER_SIZE,
                                Adapter->PacketHeader.PacketLength - DRIVER_HEADER_SIZE);
    } else {
        NdisMEthIndicateReceive(Adapter->MiniportAdapterHandle,
                                NULL,
                                (PVOID)&Adapter->Lookahead,
                                IndicateLength,
                                NULL,
                                0,
                                0);
    }
}
   11cdd:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11ce0:	5b                   	pop    %ebx
   11ce1:	5e                   	pop    %esi
   11ce2:	5f                   	pop    %edi
   11ce3:	5d                   	pop    %ebp
   11ce4:	c3                   	ret    
   11ce5:	8b 46 08             	mov    0x8(%esi),%eax
   11ce8:	6a 00                	push   $0x0
   11cea:	6a 00                	push   $0x0
   11cec:	6a 00                	push   $0x0
   11cee:	53                   	push   %ebx
   11cef:	57                   	push   %edi
   11cf0:	57                   	push   %edi
   11cf1:	6a 00                	push   $0x0
   11cf3:	8b 90 d8 00 00 00    	mov    0xd8(%eax),%edx
   11cf9:	52                   	push   %edx
   11cfa:	ff 90 64 01 00 00    	call   *0x164(%eax)
   11d00:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11d03:	5b                   	pop    %ebx
   11d04:	5e                   	pop    %esi
   11d05:	5f                   	pop    %edi
   11d06:	5d                   	pop    %ebp
   11d07:	c3                   	ret    
   11d08:	90                   	nop    
   11d09:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011d10 <_NICReadPacket>:


VOID NICReadPacket(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Reads a full packet from the receive buffer ring
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   11d10:	55                   	push   %ebp
   11d11:	89 e5                	mov    %esp,%ebp
   11d13:	53                   	push   %ebx
   11d14:	51                   	push   %ecx
   11d15:	8b 5d 08             	mov    0x8(%ebp),%ebx
    BOOLEAN SkipPacket = FALSE;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Get the header of the next packet in the receive ring */
    Adapter->PacketOffset = Adapter->NextPacket << 8;
   11d18:	8b 83 e0 01 00 00    	mov    0x1e0(%ebx),%eax
   11d1e:	c1 e0 08             	shl    $0x8,%eax
   11d21:	89 83 ec 01 00 00    	mov    %eax,0x1ec(%ebx)
    NICReadData(Adapter,
   11d27:	6a 04                	push   $0x4
   11d29:	50                   	push   %eax
   11d2a:	8d 83 e8 01 00 00    	lea    0x1e8(%ebx),%eax
   11d30:	50                   	push   %eax
   11d31:	53                   	push   %ebx
   11d32:	e8 89 fd ff ff       	call   11ac0 <_NICReadData>
                (PUCHAR)&Adapter->PacketHeader,
                Adapter->PacketOffset,
                sizeof(PACKET_HEADER));

    NDIS_DbgPrint(MAX_TRACE, ("HEADER: (Status)       (0x%X)\n", Adapter->PacketHeader.Status));
    NDIS_DbgPrint(MAX_TRACE, ("HEADER: (NextPacket)   (0x%X)\n", Adapter->PacketHeader.NextPacket));
    NDIS_DbgPrint(MAX_TRACE, ("HEADER: (PacketLength) (0x%X)\n", Adapter->PacketHeader.PacketLength));

    if (Adapter->PacketHeader.PacketLength < 64  ||
   11d37:	66 8b 83 ea 01 00 00 	mov    0x1ea(%ebx),%ax
   11d3e:	83 e8 40             	sub    $0x40,%eax
   11d41:	83 c4 10             	add    $0x10,%esp
   11d44:	66 3d ae 05          	cmp    $0x5ae,%ax
   11d48:	76 18                	jbe    11d62 <_NICReadPacket+0x52>
        Adapter->PacketHeader.PacketLength > 1518) {	/* XXX I don't think the CRC will show up... should be 1514 */
        NDIS_DbgPrint(MAX_TRACE, ("Bogus packet size (%d).\n",
            Adapter->PacketHeader.PacketLength));
        SkipPacket = TRUE;
    }

    if (SkipPacket) {
        /* Skip packet */
        Adapter->NextPacket = Adapter->CurrentPage;
   11d4a:	8b 83 dc 01 00 00    	mov    0x1dc(%ebx),%eax
   11d50:	89 83 e0 01 00 00    	mov    %eax,0x1e0(%ebx)
    } else {
	NDIS_DbgPrint(MAX_TRACE,("Adapter->MiniportAdapterHandle: %x\n",
				 Adapter->MiniportAdapterHandle));
        NICIndicatePacket(Adapter);

        /* Go to the next free buffer in receive ring */
        Adapter->NextPacket = Adapter->PacketHeader.NextPacket;
    }

    /* Update boundary page */
    NICSetBoundaryPage(Adapter);
   11d56:	89 5d 08             	mov    %ebx,0x8(%ebp)
   11d59:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11d5c:	c9                   	leave  
   11d5d:	e9 fe f7 ff ff       	jmp    11560 <_NICSetBoundaryPage>
   11d62:	83 ec 0c             	sub    $0xc,%esp
   11d65:	53                   	push   %ebx
   11d66:	e8 e5 fe ff ff       	call   11c50 <_NICIndicatePacket>
   11d6b:	31 c0                	xor    %eax,%eax
   11d6d:	83 c4 10             	add    $0x10,%esp
   11d70:	8a 83 e9 01 00 00    	mov    0x1e9(%ebx),%al
   11d76:	89 83 e0 01 00 00    	mov    %eax,0x1e0(%ebx)
   11d7c:	89 5d 08             	mov    %ebx,0x8(%ebp)
   11d7f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11d82:	c9                   	leave  
   11d83:	e9 d8 f7 ff ff       	jmp    11560 <_NICSetBoundaryPage>
   11d88:	90                   	nop    
   11d89:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011d90 <_NICWritePacket>:
}


VOID NICWritePacket(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Writes a full packet to the transmit buffer ring
 * ARGUMENTS:
 *     Adapter  = Pointer to adapter information
 * NOTES:
 *     There must be enough free buffers available in the transmit buffer ring.
 *     The packet is taken from the head of the transmit queue and the position
 *     into the transmit buffer ring is taken from TXNext
 */
{
   11d90:	55                   	push   %ebp
   11d91:	89 e5                	mov    %esp,%ebp
   11d93:	57                   	push   %edi
   11d94:	56                   	push   %esi
   11d95:	53                   	push   %ebx
   11d96:	83 ec 2c             	sub    $0x2c,%esp
    PNDIS_BUFFER SrcBuffer;
    UINT BytesToCopy, SrcSize, DstSize;
    PUCHAR SrcData;
    ULONG DstData;
    UINT TXStart;
    UINT TXStop;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    TXStart = Adapter->TXStart * DRIVER_BLOCK_SIZE;
   11d99:	8b 55 08             	mov    0x8(%ebp),%edx
   11d9c:	8b 82 f4 01 00 00    	mov    0x1f4(%edx),%eax
    TXStop  = (Adapter->TXStart + Adapter->TXCount) * DRIVER_BLOCK_SIZE;
   11da2:	8b 8a f8 01 00 00    	mov    0x1f8(%edx),%ecx
   11da8:	89 c3                	mov    %eax,%ebx
   11daa:	01 c8                	add    %ecx,%eax
   11dac:	c1 e0 08             	shl    $0x8,%eax
   11daf:	c1 e3 08             	shl    $0x8,%ebx
   11db2:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)

    NdisQueryPacket(Adapter->TXQueueHead,
   11db5:	89 d0                	mov    %edx,%eax
   11db7:	8b 92 38 02 00 00    	mov    0x238(%edx),%edx
   11dbd:	89 5d dc             	mov    %ebx,0xffffffdc(%ebp)
   11dc0:	8b 88 00 02 00 00    	mov    0x200(%eax),%ecx
   11dc6:	8b 5a 08             	mov    0x8(%edx),%ebx
   11dc9:	89 5d e0             	mov    %ebx,0xffffffe0(%ebp)
   11dcc:	8d 04 88             	lea    (%eax,%ecx,4),%eax
   11dcf:	3d fc fd ff ff       	cmp    $0xfffffdfc,%eax
   11dd4:	74 27                	je     11dfd <_NICWritePacket+0x6d>
   11dd6:	80 7a 1c 00          	cmpb   $0x0,0x1c(%edx)
   11dda:	0f 84 c7 00 00 00    	je     11ea7 <_NICWritePacket+0x117>
   11de0:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11de3:	8d 04 8b             	lea    (%ebx,%ecx,4),%eax
   11de6:	3d fc fd ff ff       	cmp    $0xfffffdfc,%eax
   11deb:	74 10                	je     11dfd <_NICWritePacket+0x6d>
   11ded:	8b 83 38 02 00 00    	mov    0x238(%ebx),%eax
   11df3:	8b 40 04             	mov    0x4(%eax),%eax
   11df6:	89 84 8b 04 02 00 00 	mov    %eax,0x204(%ebx,%ecx,4)
                    NULL,
                    NULL,
                    &SrcBuffer,
                    &Adapter->TXSize[Adapter->TXNext]);

    NDIS_DbgPrint(MID_TRACE, ("Packet (%d) is now size (%d).\n",
        Adapter->TXNext,
        Adapter->TXSize[Adapter->TXNext]));

    NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
   11dfd:	50                   	push   %eax
   11dfe:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11e01:	8d 55 e4             	lea    0xffffffe4(%ebp),%edx
   11e04:	50                   	push   %eax
   11e05:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11e08:	52                   	push   %edx
   11e09:	50                   	push   %eax
   11e0a:	e8 91 11 00 00       	call   12fa0 <_NdisQueryBuffer@12>

    DstData = TXStart + Adapter->TXNext * DRIVER_BLOCK_SIZE;
   11e0f:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11e12:	8b 83 00 02 00 00    	mov    0x200(%ebx),%eax
   11e18:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   11e1b:	c1 e0 08             	shl    $0x8,%eax
    DstSize = TXStop - DstData;
   11e1e:	8b 75 d8             	mov    0xffffffd8(%ebp),%esi
   11e21:	8d 3c 10             	lea    (%eax,%edx,1),%edi

    /* Start copying the data */
    for (;;) {
   11e24:	58                   	pop    %eax
   11e25:	29 fe                	sub    %edi,%esi
   11e27:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11e2a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
        BytesToCopy = (SrcSize < DstSize)? SrcSize : DstSize;
   11e30:	89 f3                	mov    %esi,%ebx
   11e32:	39 c6                	cmp    %eax,%esi
   11e34:	76 02                	jbe    11e38 <_NICWritePacket+0xa8>
   11e36:	89 c3                	mov    %eax,%ebx

        NICWriteData(Adapter, DstData, SrcData, BytesToCopy);
   11e38:	89 d8                	mov    %ebx,%eax

        SrcData = (PUCHAR)((ULONG_PTR) SrcData + BytesToCopy);
        SrcSize            -= BytesToCopy;
        DstData            += BytesToCopy;
        DstSize            -= BytesToCopy;
   11e3a:	29 de                	sub    %ebx,%esi
   11e3c:	25 ff ff 00 00       	and    $0xffff,%eax
   11e41:	50                   	push   %eax
   11e42:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11e45:	50                   	push   %eax
   11e46:	8b 45 08             	mov    0x8(%ebp),%eax
   11e49:	57                   	push   %edi
   11e4a:	50                   	push   %eax
   11e4b:	e8 20 fd ff ff       	call   11b70 <_NICWriteData>
   11e50:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11e53:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11e56:	01 d9                	add    %ebx,%ecx
   11e58:	29 d8                	sub    %ebx,%eax
   11e5a:	01 df                	add    %ebx,%edi

        if (SrcSize == 0) {
   11e5c:	83 c4 10             	add    $0x10,%esp
   11e5f:	89 4d e4             	mov    %ecx,0xffffffe4(%ebp)
   11e62:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11e65:	85 c0                	test   %eax,%eax
   11e67:	75 23                	jne    11e8c <_NICWritePacket+0xfc>
            /* No more bytes in source buffer. Proceed to
               the next buffer in the source buffer chain */
            NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
   11e69:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
   11e6c:	8b 03                	mov    (%ebx),%eax
   11e6e:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
            if (!SrcBuffer)
   11e71:	85 c0                	test   %eax,%eax
   11e73:	0f 84 91 00 00 00    	je     11f0a <_NICWritePacket+0x17a>
                break;

            NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
   11e79:	8d 5d e4             	lea    0xffffffe4(%ebp),%ebx
   11e7c:	52                   	push   %edx
   11e7d:	8d 55 e8             	lea    0xffffffe8(%ebp),%edx
   11e80:	52                   	push   %edx
   11e81:	53                   	push   %ebx
   11e82:	50                   	push   %eax
   11e83:	e8 18 11 00 00       	call   12fa0 <_NdisQueryBuffer@12>
   11e88:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11e8b:	5b                   	pop    %ebx
        }

        if (DstSize == 0) {
   11e8c:	85 f6                	test   %esi,%esi
   11e8e:	75 a0                	jne    11e30 <_NICWritePacket+0xa0>
            /* Wrap around the end of the transmit buffer ring */
            DstData = TXStart;
            DstSize = Adapter->TXCount * DRIVER_BLOCK_SIZE;
   11e90:	8b 55 08             	mov    0x8(%ebp),%edx
   11e93:	8b 7d dc             	mov    0xffffffdc(%ebp),%edi
   11e96:	8b b2 f8 01 00 00    	mov    0x1f8(%edx),%esi
   11e9c:	c1 e6 08             	shl    $0x8,%esi
   11e9f:	89 f3                	mov    %esi,%ebx
   11ea1:	39 c6                	cmp    %eax,%esi
   11ea3:	76 93                	jbe    11e38 <_NICWritePacket+0xa8>
   11ea5:	eb 8f                	jmp    11e36 <_NICWritePacket+0xa6>
   11ea7:	31 f6                	xor    %esi,%esi
   11ea9:	31 ff                	xor    %edi,%edi
   11eab:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
   11eb2:	85 db                	test   %ebx,%ebx
   11eb4:	74 37                	je     11eed <_NICWritePacket+0x15d>
   11eb6:	83 ec 0c             	sub    $0xc,%esp
   11eb9:	53                   	push   %ebx
   11eba:	e8 f1 10 00 00       	call   12fb0 <_NDIS_BUFFER_TO_SPAN_PAGES@4>
   11ebf:	01 c6                	add    %eax,%esi
   11ec1:	58                   	pop    %eax
   11ec2:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11ec5:	5a                   	pop    %edx
   11ec6:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
   11ec9:	50                   	push   %eax
   11eca:	52                   	push   %edx
   11ecb:	53                   	push   %ebx
   11ecc:	e8 ef 10 00 00       	call   12fc0 <_NdisQueryBufferOffset@12>
   11ed1:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   11ed4:	42                   	inc    %edx
   11ed5:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11ed8:	8b 1b                	mov    (%ebx),%ebx
   11eda:	01 cf                	add    %ecx,%edi
   11edc:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
   11edf:	58                   	pop    %eax
   11ee0:	85 db                	test   %ebx,%ebx
   11ee2:	75 d2                	jne    11eb6 <_NICWritePacket+0x126>
   11ee4:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11ee7:	8b 93 38 02 00 00    	mov    0x238(%ebx),%edx
   11eed:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   11ef0:	c6 42 1c 01          	movb   $0x1,0x1c(%edx)
   11ef4:	89 32                	mov    %esi,(%edx)
   11ef6:	89 7a 04             	mov    %edi,0x4(%edx)
   11ef9:	89 42 14             	mov    %eax,0x14(%edx)
   11efc:	8b 55 08             	mov    0x8(%ebp),%edx
   11eff:	8b 8a 00 02 00 00    	mov    0x200(%edx),%ecx
   11f05:	e9 d6 fe ff ff       	jmp    11de0 <_NICWritePacket+0x50>
   11f0a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11f0d:	5b                   	pop    %ebx
   11f0e:	5e                   	pop    %esi
   11f0f:	5f                   	pop    %edi
   11f10:	5d                   	pop    %ebp
   11f11:	c3                   	ret    
   11f12:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11f19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011f20 <_NICPrepareForTransmit>:
        }
    }
}


BOOLEAN NICPrepareForTransmit(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Prepares a packet for transmission
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * NOTES:
 *     There must be at least one packet in the transmit queue
 * RETURNS:
 *     TRUE if a packet was prepared, FALSE if not
 */
{
   11f20:	55                   	push   %ebp
   11f21:	89 e5                	mov    %esp,%ebp
   11f23:	57                   	push   %edi
   11f24:	56                   	push   %esi
   11f25:	53                   	push   %ebx
   11f26:	83 ec 0c             	sub    $0xc,%esp
    UINT Length;
    UINT BufferCount;
    PNDIS_PACKET Packet;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    /* Calculate number of buffers needed to transmit packet */
    NdisQueryPacket(Adapter->TXQueueHead,
   11f29:	8b 55 08             	mov    0x8(%ebp),%edx
   11f2c:	8b 82 38 02 00 00    	mov    0x238(%edx),%eax
   11f32:	80 78 1c 00          	cmpb   $0x0,0x1c(%eax)
   11f36:	75 67                	jne    11f9f <_NICPrepareForTransmit+0x7f>
   11f38:	8b 58 08             	mov    0x8(%eax),%ebx
   11f3b:	31 f6                	xor    %esi,%esi
   11f3d:	31 ff                	xor    %edi,%edi
   11f3f:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   11f46:	85 db                	test   %ebx,%ebx
   11f48:	74 3d                	je     11f87 <_NICPrepareForTransmit+0x67>
   11f4a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11f50:	83 ec 0c             	sub    $0xc,%esp
   11f53:	53                   	push   %ebx
   11f54:	e8 57 10 00 00       	call   12fb0 <_NDIS_BUFFER_TO_SPAN_PAGES@4>
   11f59:	8d 4d f0             	lea    0xfffffff0(%ebp),%ecx
   11f5c:	01 c6                	add    %eax,%esi
   11f5e:	58                   	pop    %eax
   11f5f:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
   11f62:	5a                   	pop    %edx
   11f63:	51                   	push   %ecx
   11f64:	50                   	push   %eax
   11f65:	53                   	push   %ebx
   11f66:	e8 55 10 00 00       	call   12fc0 <_NdisQueryBufferOffset@12>
   11f6b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11f6e:	8b 1b                	mov    (%ebx),%ebx
   11f70:	01 c7                	add    %eax,%edi
   11f72:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11f75:	40                   	inc    %eax
   11f76:	85 db                	test   %ebx,%ebx
   11f78:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11f7b:	58                   	pop    %eax
   11f7c:	75 d2                	jne    11f50 <_NICPrepareForTransmit+0x30>
   11f7e:	8b 55 08             	mov    0x8(%ebp),%edx
   11f81:	8b 82 38 02 00 00    	mov    0x238(%edx),%eax
   11f87:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11f8a:	c6 40 1c 01          	movb   $0x1,0x1c(%eax)
   11f8e:	8b 55 08             	mov    0x8(%ebp),%edx
   11f91:	89 30                	mov    %esi,(%eax)
   11f93:	89 78 04             	mov    %edi,0x4(%eax)
   11f96:	89 48 14             	mov    %ecx,0x14(%eax)
   11f99:	8b 82 38 02 00 00    	mov    0x238(%edx),%eax
                    NULL,
                    NULL,
                    NULL,
                    &Length);

    BufferCount = (Length + DRIVER_BLOCK_SIZE - 1) / DRIVER_BLOCK_SIZE;
   11f9f:	8b 58 04             	mov    0x4(%eax),%ebx

    if (BufferCount > Adapter->TXFree) {
   11fa2:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11fa5:	81 c3 ff 00 00 00    	add    $0xff,%ebx
        NDIS_DbgPrint(MID_TRACE, ("No transmit resources. Have (%d) buffers, need (%d).\n",
            Adapter->TXFree, BufferCount));
        /* We don't have the resources to transmit this packet right now */
        return FALSE;
   11fab:	31 c0                	xor    %eax,%eax
   11fad:	c1 eb 08             	shr    $0x8,%ebx
   11fb0:	39 99 fc 01 00 00    	cmp    %ebx,0x1fc(%ecx)
   11fb6:	73 08                	jae    11fc0 <_NICPrepareForTransmit+0xa0>
    }

    /* Write the packet to the card */
    NICWritePacket(Adapter);

    /* If the NIC is not transmitting, reset the current transmit pointer */
    if (Adapter->TXCurrent == -1)
        Adapter->TXCurrent = Adapter->TXNext;

    Adapter->TXNext  = (Adapter->TXNext + BufferCount) % Adapter->TXCount;
    Adapter->TXFree -= BufferCount;

    /* Remove the packet from the queue */
    Packet = Adapter->TXQueueHead;
    Adapter->TXQueueHead = RESERVED(Packet)->Next;

    if (Packet == Adapter->TXQueueTail)
        Adapter->TXQueueTail = NULL;

    /* Assume the transmit went well */
    NdisMSendComplete(Adapter->MiniportAdapterHandle,
                      Packet,
                      NDIS_STATUS_SUCCESS);

    return TRUE;
}
   11fb8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11fbb:	5b                   	pop    %ebx
   11fbc:	5e                   	pop    %esi
   11fbd:	5f                   	pop    %edi
   11fbe:	5d                   	pop    %ebp
   11fbf:	c3                   	ret    
   11fc0:	83 ec 0c             	sub    $0xc,%esp
   11fc3:	51                   	push   %ecx
   11fc4:	e8 c7 fd ff ff       	call   11d90 <_NICWritePacket>
   11fc9:	8b 45 08             	mov    0x8(%ebp),%eax
   11fcc:	83 c4 10             	add    $0x10,%esp
   11fcf:	83 b8 34 02 00 00 ff 	cmpl   $0xffffffff,0x234(%eax)
   11fd6:	74 5f                	je     12037 <_NICPrepareForTransmit+0x117>
   11fd8:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11fdb:	8b 81 00 02 00 00    	mov    0x200(%ecx),%eax
   11fe1:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11fe4:	01 d8                	add    %ebx,%eax
   11fe6:	31 d2                	xor    %edx,%edx
   11fe8:	f7 b1 f8 01 00 00    	divl   0x1f8(%ecx)
   11fee:	89 91 00 02 00 00    	mov    %edx,0x200(%ecx)
   11ff4:	8b 91 38 02 00 00    	mov    0x238(%ecx),%edx
   11ffa:	8b b1 fc 01 00 00    	mov    0x1fc(%ecx),%esi
   12000:	29 de                	sub    %ebx,%esi
   12002:	8b 42 20             	mov    0x20(%edx),%eax
   12005:	89 b1 fc 01 00 00    	mov    %esi,0x1fc(%ecx)
   1200b:	89 81 38 02 00 00    	mov    %eax,0x238(%ecx)
   12011:	39 91 3c 02 00 00    	cmp    %edx,0x23c(%ecx)
   12017:	74 2e                	je     12047 <_NICPrepareForTransmit+0x127>
   12019:	53                   	push   %ebx
   1201a:	8b 4d 08             	mov    0x8(%ebp),%ecx
   1201d:	8b 41 08             	mov    0x8(%ecx),%eax
   12020:	6a 00                	push   $0x0
   12022:	52                   	push   %edx
   12023:	50                   	push   %eax
   12024:	ff 90 ec 00 00 00    	call   *0xec(%eax)
   1202a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1202d:	b8 01 00 00 00       	mov    $0x1,%eax
   12032:	5b                   	pop    %ebx
   12033:	5e                   	pop    %esi
   12034:	5f                   	pop    %edi
   12035:	5d                   	pop    %ebp
   12036:	c3                   	ret    
   12037:	89 c2                	mov    %eax,%edx
   12039:	8b 80 00 02 00 00    	mov    0x200(%eax),%eax
   1203f:	89 82 34 02 00 00    	mov    %eax,0x234(%edx)
   12045:	eb 9a                	jmp    11fe1 <_NICPrepareForTransmit+0xc1>
   12047:	c7 81 3c 02 00 00 00 	movl   $0x0,0x23c(%ecx)
   1204e:	00 00 00 
   12051:	eb c6                	jmp    12019 <_NICPrepareForTransmit+0xf9>
   12053:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12059:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012060 <_NICTransmit>:


VOID NICTransmit(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Starts transmitting packets in the transmit queue
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * NOTES:
 *     There must be at least one packet in the transmit queue
 */
{
   12060:	55                   	push   %ebp
   12061:	89 e5                	mov    %esp,%ebp
   12063:	53                   	push   %ebx
   12064:	51                   	push   %ecx
   12065:	8b 5d 08             	mov    0x8(%ebp),%ebx
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    if (Adapter->TXCurrent == -1) {
   12068:	83 bb 34 02 00 00 ff 	cmpl   $0xffffffff,0x234(%ebx)
   1206f:	74 05                	je     12076 <_NICTransmit+0x16>
        /* NIC is not transmitting, so start transmitting now */

        /* Load next packet onto the card, and start transmitting */
        if (NICPrepareForTransmit(Adapter))
            NICStartTransmit(Adapter);
    }
}
   12071:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12074:	c9                   	leave  
   12075:	c3                   	ret    
   12076:	83 ec 0c             	sub    $0xc,%esp
   12079:	53                   	push   %ebx
   1207a:	e8 a1 fe ff ff       	call   11f20 <_NICPrepareForTransmit>
   1207f:	83 c4 10             	add    $0x10,%esp
   12082:	84 c0                	test   %al,%al
   12084:	74 eb                	je     12071 <_NICTransmit+0x11>
   12086:	89 5d 08             	mov    %ebx,0x8(%ebp)
   12089:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1208c:	c9                   	leave  
   1208d:	e9 4e f4 ff ff       	jmp    114e0 <_NICStartTransmit>
   12092:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12099:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000120a0 <_HandleReceive>:


VOID HandleReceive(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Handles reception of a packet
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 * NOTES:
 *     Buffer overflows are also handled here
 */
{
   120a0:	55                   	push   %ebp
   120a1:	89 e5                	mov    %esp,%ebp
   120a3:	57                   	push   %edi
   120a4:	56                   	push   %esi
   120a5:	53                   	push   %ebx
   120a6:	83 ec 18             	sub    $0x18,%esp
    UINT i;
    UCHAR Tmp;
    UINT PacketCount;

    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));

    Adapter->DoneIndicating = FALSE;
    PacketCount = 0;
   120a9:	31 f6                	xor    %esi,%esi
   120ab:	8b 5d 08             	mov    0x8(%ebp),%ebx
   120ae:	c6 83 f0 01 00 00 00 	movb   $0x0,0x1f0(%ebx)

    NICGetCurrentPage(Adapter);
   120b5:	53                   	push   %ebx
   120b6:	e8 f5 f4 ff ff       	call   115b0 <_NICGetCurrentPage>

    if (Adapter->BufferOverflow) {
   120bb:	83 c4 10             	add    $0x10,%esp
   120be:	80 bb e4 01 00 00 00 	cmpb   $0x0,0x1e4(%ebx)
   120c5:	0f 85 9e 00 00 00    	jne    12169 <_HandleReceive+0xc9>

        NDIS_DbgPrint(MID_TRACE, ("Receive ring overflow.\n"));

        /* Select page 0 and stop the NIC */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2 | CR_PAGE0);
        
        /* Clear RBCR0,RBCR1 - Remote Byte Count Registers */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR0, 0x00);
        NdisRawWritePortUchar(Adapter->IOBase + PG0_RBCR1, 0x00);

        /* Wait for ISR_RST to be set, but timeout after 2ms */
        for (i = 0; i < 4; i++) {
            NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &Tmp);
            if (Tmp & ISR_RST)
                break;

            NdisStallExecution(500);
        }

#ifdef DBG
        if (i == 4)
            NDIS_DbgPrint(MIN_TRACE, ("NIC was not reset after 2ms.\n"));
#endif

        if ((Adapter->InterruptStatus & (ISR_PTX | ISR_TXE)) == 0) {
            /* We may need to restart the transmitter */
            Adapter->TransmitPending = TRUE;
        }

        /* Initialize TCR - Transmit Configuration Register to loopback mode 1 */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_TCR, TCR_LOOP);

        /* Start NIC */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STA | CR_RD2);

        NICStart(Adapter);

        Adapter->BufferOverflow = FALSE;
    }

    if (Adapter->ReceiveError) {
   120cb:	80 bb e5 01 00 00 00 	cmpb   $0x0,0x1e5(%ebx)
   120d2:	75 71                	jne    12145 <_HandleReceive+0xa5>
        NDIS_DbgPrint(MID_TRACE, ("Receive error.\n"));

        /* Skip this packet */
        Adapter->NextPacket = Adapter->CurrentPage;
        NICSetBoundaryPage(Adapter);

        Adapter->ReceiveError = FALSE;
    }

    for (;;) {
        NICGetCurrentPage(Adapter);
   120d4:	83 ec 0c             	sub    $0xc,%esp
   120d7:	53                   	push   %ebx
   120d8:	e8 d3 f4 ff ff       	call   115b0 <_NICGetCurrentPage>

        NDIS_DbgPrint(MID_TRACE, ("Current page (0x%X)  NextPacket (0x%X).\n",
            Adapter->CurrentPage,
            Adapter->NextPacket));

        if (Adapter->CurrentPage == Adapter->NextPacket) {
   120dd:	8b 83 e0 01 00 00    	mov    0x1e0(%ebx),%eax
   120e3:	83 c4 10             	add    $0x10,%esp
   120e6:	39 83 dc 01 00 00    	cmp    %eax,0x1dc(%ebx)
   120ec:	74 19                	je     12107 <_HandleReceive+0x67>
            NDIS_DbgPrint(MID_TRACE, ("No more packets.\n"));
            break;
        } else {
            NDIS_DbgPrint(MID_TRACE, ("Got a packet in the receive ring.\n"));

	    NDIS_DbgPrint(MAX_TRACE,("Adapter->MiniportAdapterHandle: %x\n",
				     Adapter->MiniportAdapterHandle));
            /* Read packet from receive buffer ring */
            NICReadPacket(Adapter);
   120ee:	83 ec 0c             	sub    $0xc,%esp

            Adapter->DoneIndicating = TRUE;

            PacketCount++;
   120f1:	46                   	inc    %esi
   120f2:	53                   	push   %ebx
   120f3:	e8 18 fc ff ff       	call   11d10 <_NICReadPacket>
            if (PacketCount == 10) {
   120f8:	83 c4 10             	add    $0x10,%esp
   120fb:	c6 83 f0 01 00 00 01 	movb   $0x1,0x1f0(%ebx)
   12102:	83 fe 0a             	cmp    $0xa,%esi
   12105:	75 cd                	jne    120d4 <_HandleReceive+0x34>
                /* Don't starve transmit interrupts */
                break;
            }
        }
    }

    if ((Adapter->TransmitPending) && (Adapter->TXCurrent != -1)) {
   12107:	80 bb e7 01 00 00 00 	cmpb   $0x0,0x1e7(%ebx)
   1210e:	74 20                	je     12130 <_HandleReceive+0x90>
   12110:	83 bb 34 02 00 00 ff 	cmpl   $0xffffffff,0x234(%ebx)
   12117:	74 17                	je     12130 <_HandleReceive+0x90>
        NDIS_DbgPrint(MID_TRACE, ("Retransmitting current packet at (%d).\n", Adapter->TXCurrent));
        /* Retransmit packet */
        NICStartTransmit(Adapter);
   12119:	83 ec 0c             	sub    $0xc,%esp
   1211c:	53                   	push   %ebx
   1211d:	e8 be f3 ff ff       	call   114e0 <_NICStartTransmit>
        Adapter->TransmitPending = FALSE;
   12122:	c6 83 e7 01 00 00 00 	movb   $0x0,0x1e7(%ebx)
   12129:	83 c4 10             	add    $0x10,%esp
   1212c:	8d 74 26 00          	lea    0x0(%esi),%esi
    }

    if (Adapter->DoneIndicating)
   12130:	80 bb f0 01 00 00 00 	cmpb   $0x0,0x1f0(%ebx)
   12137:	0f 85 c9 00 00 00    	jne    12206 <_HandleReceive+0x166>
        NdisMEthIndicateReceiveComplete(Adapter->MiniportAdapterHandle);
}
   1213d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12140:	5b                   	pop    %ebx
   12141:	5e                   	pop    %esi
   12142:	5f                   	pop    %edi
   12143:	5d                   	pop    %ebp
   12144:	c3                   	ret    
   12145:	8b 83 dc 01 00 00    	mov    0x1dc(%ebx),%eax
   1214b:	83 ec 0c             	sub    $0xc,%esp
   1214e:	89 83 e0 01 00 00    	mov    %eax,0x1e0(%ebx)
   12154:	53                   	push   %ebx
   12155:	e8 06 f4 ff ff       	call   11560 <_NICSetBoundaryPage>
   1215a:	83 c4 10             	add    $0x10,%esp
   1215d:	c6 83 e5 01 00 00 00 	movb   $0x0,0x1e5(%ebx)
   12164:	e9 6b ff ff ff       	jmp    120d4 <_HandleReceive+0x34>
   12169:	57                   	push   %edi
   1216a:	57                   	push   %edi
   1216b:	6a 21                	push   $0x21
   1216d:	8b 4b 60             	mov    0x60(%ebx),%ecx
   12170:	31 ff                	xor    %edi,%edi
   12172:	51                   	push   %ecx
   12173:	e8 78 0f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   12178:	6a 00                	push   $0x0
   1217a:	8b 43 60             	mov    0x60(%ebx),%eax
   1217d:	83 c0 0a             	add    $0xa,%eax
   12180:	50                   	push   %eax
   12181:	e8 6a 0f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   12186:	6a 00                	push   $0x0
   12188:	8b 43 60             	mov    0x60(%ebx),%eax
   1218b:	83 c0 0b             	add    $0xb,%eax
   1218e:	50                   	push   %eax
   1218f:	e8 5c 0f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   12194:	58                   	pop    %eax
   12195:	5a                   	pop    %edx
   12196:	83 ec 0c             	sub    $0xc,%esp
   12199:	8b 43 60             	mov    0x60(%ebx),%eax
   1219c:	83 c0 07             	add    $0x7,%eax
   1219f:	50                   	push   %eax
   121a0:	e8 6b 0f 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   121a5:	83 c4 0c             	add    $0xc,%esp
   121a8:	84 c0                	test   %al,%al
   121aa:	78 16                	js     121c2 <_HandleReceive+0x122>
   121ac:	83 ec 0c             	sub    $0xc,%esp
   121af:	47                   	inc    %edi
   121b0:	68 f4 01 00 00       	push   $0x1f4
   121b5:	e8 46 0f 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   121ba:	83 c4 0c             	add    $0xc,%esp
   121bd:	83 ff 03             	cmp    $0x3,%edi
   121c0:	76 d4                	jbe    12196 <_HandleReceive+0xf6>
   121c2:	31 c0                	xor    %eax,%eax
   121c4:	8a 83 cc 00 00 00    	mov    0xcc(%ebx),%al
   121ca:	a8 0a                	test   $0xa,%al
   121cc:	75 07                	jne    121d5 <_HandleReceive+0x135>
   121ce:	c6 83 e7 01 00 00 01 	movb   $0x1,0x1e7(%ebx)
   121d5:	50                   	push   %eax
   121d6:	50                   	push   %eax
   121d7:	6a 02                	push   $0x2
   121d9:	8b 43 60             	mov    0x60(%ebx),%eax
   121dc:	83 c0 0d             	add    $0xd,%eax
   121df:	50                   	push   %eax
   121e0:	e8 0b 0f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   121e5:	6a 22                	push   $0x22
   121e7:	8b 43 60             	mov    0x60(%ebx),%eax
   121ea:	50                   	push   %eax
   121eb:	e8 00 0f 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   121f0:	57                   	push   %edi
   121f1:	53                   	push   %ebx
   121f2:	e8 b9 f1 ff ff       	call   113b0 <_NICStart>
   121f7:	83 c4 10             	add    $0x10,%esp
   121fa:	c6 83 e4 01 00 00 00 	movb   $0x0,0x1e4(%ebx)
   12201:	e9 c5 fe ff ff       	jmp    120cb <_HandleReceive+0x2b>
   12206:	8b 43 08             	mov    0x8(%ebx),%eax
   12209:	83 ec 0c             	sub    $0xc,%esp
   1220c:	8b 98 d8 00 00 00    	mov    0xd8(%eax),%ebx
   12212:	53                   	push   %ebx
   12213:	ff 90 70 01 00 00    	call   *0x170(%eax)
   12219:	83 c4 0c             	add    $0xc,%esp
   1221c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1221f:	5b                   	pop    %ebx
   12220:	5e                   	pop    %esi
   12221:	5f                   	pop    %edi
   12222:	5d                   	pop    %ebp
   12223:	c3                   	ret    
   12224:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1222a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00012230 <_HandleTransmit>:


VOID HandleTransmit(
    PNIC_ADAPTER Adapter)
/*
 * FUNCTION: Handles transmission of a packet
 * ARGUMENTS:
 *     Adapter = Pointer to adapter information
 */
{
   12230:	55                   	push   %ebp
   12231:	89 e5                	mov    %esp,%ebp
   12233:	53                   	push   %ebx
   12234:	53                   	push   %ebx
   12235:	8b 5d 08             	mov    0x8(%ebp),%ebx
    UINT Length;
    UINT BufferCount;

//    PIP_PACKET pIPPacket;
//    pIPPacket = (PIP_PACKET)
//    DisplayIPPacket(pIPPacket);

    if (Adapter->TransmitError) {
   12238:	80 bb e6 01 00 00 00 	cmpb   $0x0,0x1e6(%ebx)
   1223f:	74 07                	je     12248 <_HandleTransmit+0x18>
        /* FIXME: Retransmit now or let upper layer protocols handle retransmit? */
        Adapter->TransmitError = FALSE;
   12241:	c6 83 e6 01 00 00 00 	movb   $0x0,0x1e6(%ebx)
    }

    /* Free transmit buffers */
    Length      = Adapter->TXSize[Adapter->TXCurrent];
   12248:	8b 83 34 02 00 00    	mov    0x234(%ebx),%eax
    BufferCount = (Length + DRIVER_BLOCK_SIZE - 1) / DRIVER_BLOCK_SIZE;

    NDIS_DbgPrint(MID_TRACE, ("Freeing (%d) buffers at (%d).\n",
        BufferCount,
        Adapter->TXCurrent));

    Adapter->TXFree += BufferCount;
   1224e:	8b 8b fc 01 00 00    	mov    0x1fc(%ebx),%ecx
   12254:	8b 94 83 04 02 00 00 	mov    0x204(%ebx,%eax,4),%edx
    Adapter->TXSize[Adapter->TXCurrent] = 0;
   1225b:	c7 84 83 04 02 00 00 	movl   $0x0,0x204(%ebx,%eax,4)
   12262:	00 00 00 00 
   12266:	81 c2 ff 00 00 00    	add    $0xff,%edx
   1226c:	c1 ea 08             	shr    $0x8,%edx
   1226f:	01 d1                	add    %edx,%ecx
    Adapter->TXCurrent = (Adapter->TXCurrent + BufferCount) % Adapter->TXCount;
   12271:	01 d0                	add    %edx,%eax
   12273:	31 d2                	xor    %edx,%edx
   12275:	89 8b fc 01 00 00    	mov    %ecx,0x1fc(%ebx)
   1227b:	f7 b3 f8 01 00 00    	divl   0x1f8(%ebx)

    if (Adapter->TXSize[Adapter->TXCurrent] == 0) {
   12281:	8b 84 93 04 02 00 00 	mov    0x204(%ebx,%edx,4),%eax
   12288:	85 c0                	test   %eax,%eax
   1228a:	75 19                	jne    122a5 <_HandleTransmit+0x75>
        NDIS_DbgPrint(MID_TRACE, ("No more packets in transmit buffer.\n"));

        Adapter->TXCurrent = -1;
    }

    if (Adapter->TXQueueTail) {
   1228c:	8b 83 3c 02 00 00    	mov    0x23c(%ebx),%eax
   12292:	c7 83 34 02 00 00 ff 	movl   $0xffffffff,0x234(%ebx)
   12299:	ff ff ff 
   1229c:	85 c0                	test   %eax,%eax
   1229e:	75 15                	jne    122b5 <_HandleTransmit+0x85>
        if (NICPrepareForTransmit(Adapter))
            NICStartTransmit(Adapter);
    }
}
   122a0:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   122a3:	c9                   	leave  
   122a4:	c3                   	ret    
   122a5:	8b 83 3c 02 00 00    	mov    0x23c(%ebx),%eax
   122ab:	89 93 34 02 00 00    	mov    %edx,0x234(%ebx)
   122b1:	85 c0                	test   %eax,%eax
   122b3:	74 eb                	je     122a0 <_HandleTransmit+0x70>
   122b5:	83 ec 0c             	sub    $0xc,%esp
   122b8:	53                   	push   %ebx
   122b9:	e8 62 fc ff ff       	call   11f20 <_NICPrepareForTransmit>
   122be:	83 c4 10             	add    $0x10,%esp
   122c1:	84 c0                	test   %al,%al
   122c3:	74 db                	je     122a0 <_HandleTransmit+0x70>
   122c5:	89 5d 08             	mov    %ebx,0x8(%ebp)
   122c8:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   122cb:	c9                   	leave  
   122cc:	e9 0f f2 ff ff       	jmp    114e0 <_NICStartTransmit>
   122d1:	eb 0d                	jmp    122e0 <_MiniportHandleInterrupt@4>
   122d3:	90                   	nop    
   122d4:	90                   	nop    
   122d5:	90                   	nop    
   122d6:	90                   	nop    
   122d7:	90                   	nop    
   122d8:	90                   	nop    
   122d9:	90                   	nop    
   122da:	90                   	nop    
   122db:	90                   	nop    
   122dc:	90                   	nop    
   122dd:	90                   	nop    
   122de:	90                   	nop    
   122df:	90                   	nop    

000122e0 <_MiniportHandleInterrupt@4>:


VOID STDCALL MiniportHandleInterrupt(
    IN  NDIS_HANDLE MiniportAdapterContext)
/*
 * FUNCTION: Handler for deferred processing of interrupts
 * ARGUMENTS:
 *     MiniportAdapterContext = Pointer to adapter context area
 * NOTES:
 *     Interrupt Service Register is read to determine which interrupts
 *     are pending. All pending interrupts are handled
 */
{
   122e0:	55                   	push   %ebp
   122e1:	89 e5                	mov    %esp,%ebp
   122e3:	56                   	push   %esi
   122e4:	53                   	push   %ebx
   122e5:	83 ec 1c             	sub    $0x1c,%esp
   122e8:	8b 75 08             	mov    0x8(%ebp),%esi
    UCHAR ISRValue;
    UCHAR ISRMask;
    UCHAR Mask;
    PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;

    ISRMask = Adapter->InterruptMask;
   122eb:	8a 86 c8 00 00 00    	mov    0xc8(%esi),%al
   122f1:	88 45 f7             	mov    %al,0xfffffff7(%ebp)
    NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &ISRValue);
   122f4:	8b 46 60             	mov    0x60(%esi),%eax
   122f7:	83 c0 07             	add    $0x7,%eax
   122fa:	50                   	push   %eax
   122fb:	e8 10 0e 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   12300:	88 c2                	mov    %al,%dl

    NDIS_DbgPrint(MID_TRACE, ("ISRValue (0x%X).\n", ISRValue));

    Adapter->InterruptStatus |= (ISRValue & ISRMask);
   12302:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   12305:	21 d0                	and    %edx,%eax

    if (ISRValue != 0x00)
   12307:	83 c4 0c             	add    $0xc,%esp
   1230a:	08 86 cc 00 00 00    	or     %al,0xcc(%esi)
   12310:	84 d2                	test   %dl,%dl
   12312:	0f 85 96 00 00 00    	jne    123ae <_MiniportHandleInterrupt@4+0xce>
        /* Acknowledge interrupts */
        NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, ISRValue);

    Mask = 0x01;
   12318:	b3 01                	mov    $0x1,%bl
    while (Adapter->InterruptStatus != 0x00) {

        NDIS_DbgPrint(MID_TRACE, ("Adapter->InterruptStatus (0x%X)  Mask (0x%X).\n",
            Adapter->InterruptStatus, Mask));

        /* Find next interrupt type */
        while (((Adapter->InterruptStatus & Mask) == 0) && (Mask < ISRMask))
            Mask = (Mask << 1);

        switch (Adapter->InterruptStatus & Mask) {
        case ISR_OVW:   
            NDIS_DbgPrint(MID_TRACE, ("Overflow interrupt.\n"));
            /* Overflow. Handled almost the same way as a receive interrupt */
            Adapter->BufferOverflow = TRUE;

	    NDIS_DbgPrint(MAX_TRACE,("Adapter->MiniportAdapterHandle: %x\n",
				     Adapter->MiniportAdapterHandle));
	    if(Adapter->MiniportAdapterHandle)
		HandleReceive(Adapter);
	    else
		NDIS_DbgPrint(MAX_TRACE,("No miniport adapter yet\n"));

            Adapter->InterruptStatus &= ~ISR_OVW;
            break;

        case ISR_RXE:
            NDIS_DbgPrint(MID_TRACE, ("Receive error interrupt.\n"));
            NICUpdateCounters(Adapter);

            Adapter->ReceiveError = TRUE;
            
        case ISR_PRX:
            NDIS_DbgPrint(MID_TRACE, ("Receive interrupt.\n"));

	    NDIS_DbgPrint(MAX_TRACE,("Adapter->MiniportAdapterHandle: %x\n",
				     Adapter->MiniportAdapterHandle));
	    if(Adapter->MiniportAdapterHandle)
		HandleReceive(Adapter);
	    else
		NDIS_DbgPrint(MAX_TRACE,("No miniport adapter yet\n"));
	    
            Adapter->InterruptStatus &= ~(ISR_PRX | ISR_RXE);
            break;  

        case ISR_TXE:
            NDIS_DbgPrint(MID_TRACE, ("Transmit error interrupt.\n"));
            NICUpdateCounters(Adapter);

            Adapter->TransmitError = TRUE;

        case ISR_PTX:
            NDIS_DbgPrint(MID_TRACE, ("Transmit interrupt.\n"));

            HandleTransmit(Adapter);

            Adapter->InterruptStatus &= ~(ISR_PTX | ISR_TXE);
            break;

        case ISR_CNT:
            NDIS_DbgPrint(MID_TRACE, ("Counter interrupt.\n"));
            /* Counter overflow. Read counters from the NIC */
            NICUpdateCounters(Adapter);

            Adapter->InterruptStatus &= ~ISR_CNT;
            break;

        default:
            NDIS_DbgPrint(MID_TRACE, ("Unknown interrupt. Adapter->InterruptStatus (0x%X).\n", Adapter->InterruptStatus));
            Adapter->InterruptStatus &= ~Mask;
            break;
        }

        Mask = (Mask << 1);

        /* Check if new interrupts are generated */

        NdisRawReadPortUchar(Adapter->IOBase + PG0_ISR, &ISRValue);

        NDIS_DbgPrint(MID_TRACE, ("ISRValue (0x%X).\n", ISRValue));

        Adapter->InterruptStatus |= (ISRValue & ISRMask);

        if (ISRValue != 0x00) {
            /* Acknowledge interrupts */
            NdisRawWritePortUchar(Adapter->IOBase + PG0_ISR, ISRValue);
            Mask = 0x01;
   1231a:	8a 8e cc 00 00 00    	mov    0xcc(%esi),%cl
   12320:	84 c9                	test   %cl,%cl
   12322:	75 0e                	jne    12332 <_MiniportHandleInterrupt@4+0x52>
   12324:	e9 9f 00 00 00       	jmp    123c8 <_MiniportHandleInterrupt@4+0xe8>
   12329:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12330:	01 db                	add    %ebx,%ebx
   12332:	84 cb                	test   %cl,%bl
   12334:	0f 94 c2             	sete   %dl
   12337:	3a 5d f7             	cmp    0xfffffff7(%ebp),%bl
   1233a:	0f 92 c0             	setb   %al
   1233d:	25 ff 00 00 00       	and    $0xff,%eax
   12342:	85 c2                	test   %eax,%edx
   12344:	75 ea                	jne    12330 <_MiniportHandleInterrupt@4+0x50>
   12346:	88 c8                	mov    %cl,%al
   12348:	21 d8                	and    %ebx,%eax
   1234a:	25 ff 00 00 00       	and    $0xff,%eax
   1234f:	83 f8 20             	cmp    $0x20,%eax
   12352:	77 07                	ja     1235b <_MiniportHandleInterrupt@4+0x7b>
   12354:	ff 24 85 34 50 01 00 	jmp    *0x15034(,%eax,4)
   1235b:	88 d8                	mov    %bl,%al
   1235d:	83 f0 ff             	xor    $0xffffffff,%eax
   12360:	21 c1                	and    %eax,%ecx
   12362:	88 8e cc 00 00 00    	mov    %cl,0xcc(%esi)
   12368:	83 ec 0c             	sub    $0xc,%esp
   1236b:	8b 46 60             	mov    0x60(%esi),%eax
   1236e:	83 c0 07             	add    $0x7,%eax
   12371:	01 db                	add    %ebx,%ebx
   12373:	50                   	push   %eax
   12374:	e8 97 0d 00 00       	call   13110 <_READ_PORT_UCHAR@4>
   12379:	8a 4d f7             	mov    0xfffffff7(%ebp),%cl
   1237c:	83 c4 0c             	add    $0xc,%esp
   1237f:	21 c1                	and    %eax,%ecx
   12381:	0a 8e cc 00 00 00    	or     0xcc(%esi),%cl
   12387:	84 c0                	test   %al,%al
   12389:	88 8e cc 00 00 00    	mov    %cl,0xcc(%esi)
   1238f:	74 8f                	je     12320 <_MiniportHandleInterrupt@4+0x40>
   12391:	25 ff 00 00 00       	and    $0xff,%eax
   12396:	51                   	push   %ecx
   12397:	51                   	push   %ecx
   12398:	50                   	push   %eax
   12399:	b3 01                	mov    $0x1,%bl
   1239b:	8b 46 60             	mov    0x60(%esi),%eax
   1239e:	83 c0 07             	add    $0x7,%eax
   123a1:	50                   	push   %eax
   123a2:	e8 49 0d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   123a7:	58                   	pop    %eax
   123a8:	5a                   	pop    %edx
   123a9:	e9 6c ff ff ff       	jmp    1231a <_MiniportHandleInterrupt@4+0x3a>
   123ae:	31 c0                	xor    %eax,%eax
   123b0:	88 d0                	mov    %dl,%al
   123b2:	51                   	push   %ecx
   123b3:	51                   	push   %ecx
   123b4:	50                   	push   %eax
   123b5:	8b 46 60             	mov    0x60(%esi),%eax
   123b8:	83 c0 07             	add    $0x7,%eax
   123bb:	50                   	push   %eax
   123bc:	e8 2f 0d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   123c1:	58                   	pop    %eax
   123c2:	5a                   	pop    %edx
   123c3:	e9 50 ff ff ff       	jmp    12318 <_MiniportHandleInterrupt@4+0x38>
        }
    }

    NICEnableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
   123c8:	50                   	push   %eax
   123c9:	50                   	push   %eax
   123ca:	31 c0                	xor    %eax,%eax
   123cc:	8a 86 c8 00 00 00    	mov    0xc8(%esi),%al
   123d2:	50                   	push   %eax
   123d3:	8b 46 60             	mov    0x60(%esi),%eax
   123d6:	83 c0 0f             	add    $0xf,%eax
   123d9:	50                   	push   %eax
   123da:	e8 11 0d 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   123df:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   123e2:	5b                   	pop    %ebx
   123e3:	5e                   	pop    %esi
   123e4:	5d                   	pop    %ebp
   123e5:	c2 04 00             	ret    $0x4
   123e8:	83 ec 0c             	sub    $0xc,%esp
   123eb:	56                   	push   %esi
   123ec:	e8 0f f2 ff ff       	call   11600 <_NICUpdateCounters>
   123f1:	c6 86 e6 01 00 00 01 	movb   $0x1,0x1e6(%esi)
   123f8:	83 c4 10             	add    $0x10,%esp
   123fb:	83 ec 0c             	sub    $0xc,%esp
   123fe:	56                   	push   %esi
   123ff:	e8 2c fe ff ff       	call   12230 <_HandleTransmit>
   12404:	80 a6 cc 00 00 00 f5 	andb   $0xf5,0xcc(%esi)
   1240b:	83 c4 10             	add    $0x10,%esp
   1240e:	e9 55 ff ff ff       	jmp    12368 <_MiniportHandleInterrupt@4+0x88>
   12413:	83 ec 0c             	sub    $0xc,%esp
   12416:	56                   	push   %esi
   12417:	e8 e4 f1 ff ff       	call   11600 <_NICUpdateCounters>
   1241c:	c6 86 e5 01 00 00 01 	movb   $0x1,0x1e5(%esi)
   12423:	83 c4 10             	add    $0x10,%esp
   12426:	8b 46 08             	mov    0x8(%esi),%eax
   12429:	85 c0                	test   %eax,%eax
   1242b:	75 54                	jne    12481 <_MiniportHandleInterrupt@4+0x1a1>
   1242d:	80 a6 cc 00 00 00 fa 	andb   $0xfa,0xcc(%esi)
   12434:	e9 2f ff ff ff       	jmp    12368 <_MiniportHandleInterrupt@4+0x88>
   12439:	83 ec 0c             	sub    $0xc,%esp
   1243c:	56                   	push   %esi
   1243d:	e8 be f1 ff ff       	call   11600 <_NICUpdateCounters>
   12442:	80 a6 cc 00 00 00 df 	andb   $0xdf,0xcc(%esi)
   12449:	83 c4 10             	add    $0x10,%esp
   1244c:	e9 17 ff ff ff       	jmp    12368 <_MiniportHandleInterrupt@4+0x88>
   12451:	8b 46 08             	mov    0x8(%esi),%eax
   12454:	c6 86 e4 01 00 00 01 	movb   $0x1,0x1e4(%esi)
   1245b:	85 c0                	test   %eax,%eax
   1245d:	75 08                	jne    12467 <_MiniportHandleInterrupt@4+0x187>
   1245f:	83 e1 ef             	and    $0xffffffef,%ecx
   12462:	e9 fb fe ff ff       	jmp    12362 <_MiniportHandleInterrupt@4+0x82>
   12467:	83 ec 0c             	sub    $0xc,%esp
   1246a:	56                   	push   %esi
   1246b:	e8 30 fc ff ff       	call   120a0 <_HandleReceive>
   12470:	8a 8e cc 00 00 00    	mov    0xcc(%esi),%cl
   12476:	83 c4 10             	add    $0x10,%esp
   12479:	83 e1 ef             	and    $0xffffffef,%ecx
   1247c:	e9 e1 fe ff ff       	jmp    12362 <_MiniportHandleInterrupt@4+0x82>
   12481:	83 ec 0c             	sub    $0xc,%esp
   12484:	56                   	push   %esi
   12485:	e8 16 fc ff ff       	call   120a0 <_HandleReceive>
   1248a:	83 c4 10             	add    $0x10,%esp
   1248d:	eb 9e                	jmp    1242d <_MiniportHandleInterrupt@4+0x14d>
   1248f:	90                   	nop    

00012490 <_MiniportCheckForHang>:
   12490:	55                   	push   %ebp
   12491:	31 c0                	xor    %eax,%eax
   12493:	89 e5                	mov    %esp,%ebp
   12495:	5d                   	pop    %ebp
   12496:	c3                   	ret    
   12497:	89 f6                	mov    %esi,%esi
   12499:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000124a0 <_MiniportDisableInterrupt@4>:
   124a0:	55                   	push   %ebp
   124a1:	89 e5                	mov    %esp,%ebp
   124a3:	83 ec 10             	sub    $0x10,%esp
   124a6:	8b 45 08             	mov    0x8(%ebp),%eax
   124a9:	6a 00                	push   $0x0
   124ab:	8b 40 60             	mov    0x60(%eax),%eax
   124ae:	83 c0 0f             	add    $0xf,%eax
   124b1:	50                   	push   %eax
   124b2:	e8 39 0c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   124b7:	c9                   	leave  
   124b8:	c2 04 00             	ret    $0x4
   124bb:	90                   	nop    
   124bc:	8d 74 26 00          	lea    0x0(%esi),%esi

000124c0 <_MiniportEnableInterrupt@4>:
   124c0:	55                   	push   %ebp
   124c1:	31 d2                	xor    %edx,%edx
   124c3:	89 e5                	mov    %esp,%ebp
   124c5:	83 ec 10             	sub    $0x10,%esp
   124c8:	8b 45 08             	mov    0x8(%ebp),%eax
   124cb:	8a 90 c8 00 00 00    	mov    0xc8(%eax),%dl
   124d1:	52                   	push   %edx
   124d2:	8b 40 60             	mov    0x60(%eax),%eax
   124d5:	83 c0 0f             	add    $0xf,%eax
   124d8:	50                   	push   %eax
   124d9:	e8 12 0c 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   124de:	c9                   	leave  
   124df:	c2 04 00             	ret    $0x4
   124e2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   124e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000124f0 <_MiniportHalt@4>:
   124f0:	55                   	push   %ebp
   124f1:	89 e5                	mov    %esp,%ebp
   124f3:	53                   	push   %ebx
   124f4:	83 ec 10             	sub    $0x10,%esp
   124f7:	8b 5d 08             	mov    0x8(%ebp),%ebx
   124fa:	53                   	push   %ebx
   124fb:	e8 e0 ee ff ff       	call   113e0 <_NICStop>
   12500:	c7 04 24 90 d0 03 00 	movl   $0x3d090,(%esp)
   12507:	e8 f4 0b 00 00       	call   13100 <_KeStallExecutionProcessor@4>
   1250c:	83 c4 0c             	add    $0xc,%esp
   1250f:	80 bb 4d 02 00 00 00 	cmpb   $0x0,0x24d(%ebx)
   12516:	75 2c                	jne    12544 <_MiniportHalt@4+0x54>
   12518:	80 bb 4c 02 00 00 00 	cmpb   $0x0,0x24c(%ebx)
   1251f:	75 3f                	jne    12560 <_MiniportHalt@4+0x70>
   12521:	8b 53 04             	mov    0x4(%ebx),%edx
   12524:	85 d2                	test   %edx,%edx
   12526:	74 07                	je     1252f <_MiniportHalt@4+0x3f>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   12528:	8b 03                	mov    (%ebx),%eax
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
  OldBlink->Flink = OldFlink;
   1252a:	89 02                	mov    %eax,(%edx)
   1252c:	89 50 04             	mov    %edx,0x4(%eax)
   1252f:	50                   	push   %eax
   12530:	6a 00                	push   $0x0
   12532:	68 50 02 00 00       	push   $0x250
   12537:	53                   	push   %ebx
   12538:	e8 93 0a 00 00       	call   12fd0 <_NdisFreeMemory@12>
   1253d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12540:	c9                   	leave  
   12541:	c2 04 00             	ret    $0x4
   12544:	83 ec 0c             	sub    $0xc,%esp
   12547:	8d 43 0c             	lea    0xc(%ebx),%eax
   1254a:	50                   	push   %eax
   1254b:	e8 90 0a 00 00       	call   12fe0 <_NdisMDeregisterInterrupt@4>
   12550:	83 c4 0c             	add    $0xc,%esp
   12553:	80 bb 4c 02 00 00 00 	cmpb   $0x0,0x24c(%ebx)
   1255a:	74 c5                	je     12521 <_MiniportHalt@4+0x31>
   1255c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12560:	8b 43 60             	mov    0x60(%ebx),%eax
   12563:	50                   	push   %eax
   12564:	6a 20                	push   $0x20
   12566:	8b 4b 58             	mov    0x58(%ebx),%ecx
   12569:	51                   	push   %ecx
   1256a:	8b 53 08             	mov    0x8(%ebx),%edx
   1256d:	52                   	push   %edx
   1256e:	e8 7d 0a 00 00       	call   12ff0 <_NdisMDeregisterIoPortRange@16>
   12573:	eb ac                	jmp    12521 <_MiniportHalt@4+0x31>
   12575:	8d 74 26 00          	lea    0x0(%esi),%esi
   12579:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012580 <_MiniportInitialize@24>:
   12580:	55                   	push   %ebp
   12581:	31 d2                	xor    %edx,%edx
   12583:	89 e5                	mov    %esp,%ebp
   12585:	57                   	push   %edi
   12586:	56                   	push   %esi
   12587:	53                   	push   %ebx
   12588:	83 ec 2c             	sub    $0x2c,%esp
   1258b:	8b 45 14             	mov    0x14(%ebp),%eax
   1258e:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12591:	8b 7d 18             	mov    0x18(%ebp),%edi
   12594:	39 c2                	cmp    %eax,%edx
   12596:	73 0c                	jae    125a4 <_MiniportInitialize@24+0x24>
   12598:	8b 1c 91             	mov    (%ecx,%edx,4),%ebx
   1259b:	85 db                	test   %ebx,%ebx
   1259d:	74 05                	je     125a4 <_MiniportInitialize@24+0x24>
   1259f:	42                   	inc    %edx
   125a0:	39 c2                	cmp    %eax,%edx
   125a2:	72 f4                	jb     12598 <_MiniportInitialize@24+0x18>
   125a4:	b9 19 00 01 c0       	mov    $0xc0010019,%ecx
   125a9:	39 c2                	cmp    %eax,%edx
   125ab:	74 32                	je     125df <_MiniportInitialize@24+0x5f>
   125ad:	8b 45 0c             	mov    0xc(%ebp),%eax
   125b0:	83 ec 0c             	sub    $0xc,%esp
   125b3:	8b 35 24 40 01 00    	mov    0x14024,%esi
   125b9:	89 10                	mov    %edx,(%eax)
   125bb:	56                   	push   %esi
   125bc:	8b 1d 20 40 01 00    	mov    0x14020,%ebx
   125c2:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
   125c5:	53                   	push   %ebx
   125c6:	6a 00                	push   $0x0
   125c8:	68 50 02 00 00       	push   $0x250
   125cd:	50                   	push   %eax
   125ce:	e8 2d 0a 00 00       	call   13000 <_NdisAllocateMemory@20>
   125d3:	83 c4 0c             	add    $0xc,%esp
   125d6:	89 c1                	mov    %eax,%ecx
   125d8:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   125db:	85 c0                	test   %eax,%eax
   125dd:	74 0c                	je     125eb <_MiniportInitialize@24+0x6b>
   125df:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   125e2:	89 c8                	mov    %ecx,%eax
   125e4:	5b                   	pop    %ebx
   125e5:	5e                   	pop    %esi
   125e6:	5f                   	pop    %edi
   125e7:	5d                   	pop    %ebp
   125e8:	c2 18 00             	ret    $0x18
   125eb:	51                   	push   %ecx
   125ec:	51                   	push   %ecx
   125ed:	68 50 02 00 00       	push   $0x250
   125f2:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   125f5:	8d 75 e4             	lea    0xffffffe4(%ebp),%esi
   125f8:	52                   	push   %edx
   125f9:	e8 d2 0a 00 00       	call   130d0 <_RtlZeroMemory@8>
   125fe:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12601:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
   12608:	c7 80 d4 00 00 00 ee 	movl   $0xee,0xd4(%eax)
   1260f:	00 00 00 
   12612:	89 78 08             	mov    %edi,0x8(%eax)
   12615:	c7 40 58 80 02 00 00 	movl   $0x280,0x58(%eax)
   1261c:	c7 40 5c 09 00 00 00 	movl   $0x9,0x5c(%eax)
   12623:	c7 80 8c 00 00 00 08 	movl   $0x8,0x8c(%eax)
   1262a:	00 00 00 
   1262d:	c7 80 c8 00 00 00 3f 	movl   $0x3f,0xc8(%eax)
   12634:	00 00 00 
   12637:	c7 45 d0 00 00 00 00 	movl   $0x0,0xffffffd0(%ebp)
   1263e:	58                   	pop    %eax
   1263f:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12642:	50                   	push   %eax
   12643:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   12646:	50                   	push   %eax
   12647:	56                   	push   %esi
   12648:	e8 c3 09 00 00       	call   13010 <_NdisOpenConfiguration@12>
   1264d:	58                   	pop    %eax
   1264e:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12651:	85 c0                	test   %eax,%eax
   12653:	0f 84 19 01 00 00    	je     12772 <_MiniportInitialize@24+0x1f2>
   12659:	83 ec 0c             	sub    $0xc,%esp
   1265c:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   1265f:	53                   	push   %ebx
   12660:	e8 eb e9 ff ff       	call   11050 <_NICCheck>
   12665:	83 c4 10             	add    $0x10,%esp
   12668:	b9 06 00 01 c0       	mov    $0xc0010006,%ecx
   1266d:	84 c0                	test   %al,%al
   1266f:	0f 84 6a ff ff ff    	je     125df <_MiniportInitialize@24+0x5f>
   12675:	6a 01                	push   $0x1
   12677:	6a 00                	push   $0x0
   12679:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   1267c:	51                   	push   %ecx
   1267d:	57                   	push   %edi
   1267e:	e8 9d 09 00 00       	call   13020 <_NdisMSetAttributes@16>
   12683:	6a 20                	push   $0x20
   12685:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12688:	8b 50 58             	mov    0x58(%eax),%edx
   1268b:	83 c0 60             	add    $0x60,%eax
   1268e:	52                   	push   %edx
   1268f:	57                   	push   %edi
   12690:	50                   	push   %eax
   12691:	e8 9a 09 00 00       	call   13030 <_NdisMRegisterIoPortRange@16>
   12696:	85 c0                	test   %eax,%eax
   12698:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   1269b:	0f 85 b6 00 00 00    	jne    12757 <_MiniportInitialize@24+0x1d7>
   126a1:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   126a4:	83 ec 0c             	sub    $0xc,%esp
   126a7:	c6 80 4c 02 00 00 01 	movb   $0x1,0x24c(%eax)
   126ae:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   126b1:	50                   	push   %eax
   126b2:	e8 39 f3 ff ff       	call   119f0 <_NICInitialize>
   126b7:	83 c4 10             	add    $0x10,%esp
   126ba:	85 c0                	test   %eax,%eax
   126bc:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   126bf:	0f 85 92 00 00 00    	jne    12757 <_MiniportInitialize@24+0x1d7>
   126c5:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   126c8:	8b 41 68             	mov    0x68(%ecx),%eax
   126cb:	c7 81 f8 01 00 00 0c 	movl   $0xc,0x1f8(%ecx)
   126d2:	00 00 00 
   126d5:	c1 e8 08             	shr    $0x8,%eax
   126d8:	c7 81 fc 01 00 00 0c 	movl   $0xc,0x1fc(%ecx)
   126df:	00 00 00 
   126e2:	89 81 f4 01 00 00    	mov    %eax,0x1f4(%ecx)
   126e8:	c7 81 34 02 00 00 ff 	movl   $0xffffffff,0x234(%ecx)
   126ef:	ff ff ff 
   126f2:	8d 50 0c             	lea    0xc(%eax),%edx
   126f5:	89 91 d4 01 00 00    	mov    %edx,0x1d4(%ecx)
   126fb:	8b 51 6c             	mov    0x6c(%ecx),%edx
   126fe:	c1 ea 08             	shr    $0x8,%edx
   12701:	01 d0                	add    %edx,%eax
   12703:	31 d2                	xor    %edx,%edx
   12705:	89 81 d8 01 00 00    	mov    %eax,0x1d8(%ecx)
   1270b:	eb 06                	jmp    12713 <_MiniportInitialize@24+0x193>
   1270d:	8d 76 00             	lea    0x0(%esi),%esi
   12710:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   12713:	c6 84 11 c0 00 00 00 	movb   $0xff,0xc0(%ecx,%edx,1)
   1271a:	ff 
   1271b:	42                   	inc    %edx
   1271c:	83 fa 07             	cmp    $0x7,%edx
   1271f:	76 ef                	jbe    12710 <_MiniportInitialize@24+0x190>
   12721:	83 ec 0c             	sub    $0xc,%esp
   12724:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   12727:	56                   	push   %esi
   12728:	e8 43 eb ff ff       	call   11270 <_NICSetup>
   1272d:	83 c4 0c             	add    $0xc,%esp
   12730:	6a 01                	push   $0x1
   12732:	6a 00                	push   $0x0
   12734:	6a 00                	push   $0x0
   12736:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12739:	8b 58 5c             	mov    0x5c(%eax),%ebx
   1273c:	53                   	push   %ebx
   1273d:	8b 48 5c             	mov    0x5c(%eax),%ecx
   12740:	83 c0 0c             	add    $0xc,%eax
   12743:	51                   	push   %ecx
   12744:	57                   	push   %edi
   12745:	50                   	push   %eax
   12746:	e8 f5 08 00 00       	call   13040 <_NdisMRegisterInterrupt@28>
   1274b:	85 c0                	test   %eax,%eax
   1274d:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   12750:	5a                   	pop    %edx
   12751:	0f 84 b3 00 00 00    	je     1280a <_MiniportInitialize@24+0x28a>
   12757:	83 ec 0c             	sub    $0xc,%esp
   1275a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1275d:	50                   	push   %eax
   1275e:	e8 8d fd ff ff       	call   124f0 <_MiniportHalt@4>
   12763:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   12766:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12769:	89 c8                	mov    %ecx,%eax
   1276b:	5b                   	pop    %ebx
   1276c:	5e                   	pop    %esi
   1276d:	5f                   	pop    %edi
   1276e:	5d                   	pop    %ebp
   1276f:	c2 18 00             	ret    $0x18
   12772:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
   12775:	50                   	push   %eax
   12776:	50                   	push   %eax
   12777:	68 c0 50 01 00       	push   $0x150c0
   1277c:	53                   	push   %ebx
   1277d:	e8 ce 08 00 00       	call   13050 <_NdisInitUnicodeString@8>
   12782:	50                   	push   %eax
   12783:	6a 00                	push   $0x0
   12785:	53                   	push   %ebx
   12786:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
   12789:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   1278c:	51                   	push   %ecx
   1278d:	50                   	push   %eax
   1278e:	56                   	push   %esi
   1278f:	e8 cc 08 00 00       	call   13060 <_NdisReadConfiguration@20>
   12794:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   12797:	83 c4 0c             	add    $0xc,%esp
   1279a:	85 d2                	test   %edx,%edx
   1279c:	0f 84 a1 00 00 00    	je     12843 <_MiniportInitialize@24+0x2c3>
   127a2:	50                   	push   %eax
   127a3:	50                   	push   %eax
   127a4:	68 c8 50 01 00       	push   $0x150c8
   127a9:	53                   	push   %ebx
   127aa:	e8 a1 08 00 00       	call   13050 <_NdisInitUnicodeString@8>
   127af:	50                   	push   %eax
   127b0:	6a 00                	push   $0x0
   127b2:	53                   	push   %ebx
   127b3:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   127b6:	50                   	push   %eax
   127b7:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
   127ba:	50                   	push   %eax
   127bb:	56                   	push   %esi
   127bc:	e8 9f 08 00 00       	call   13060 <_NdisReadConfiguration@20>
   127c1:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   127c4:	83 c4 0c             	add    $0xc,%esp
   127c7:	85 c0                	test   %eax,%eax
   127c9:	75 0c                	jne    127d7 <_MiniportInitialize@24+0x257>
   127cb:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   127ce:	8b 50 04             	mov    0x4(%eax),%edx
   127d1:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   127d4:	89 50 58             	mov    %edx,0x58(%eax)
   127d7:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   127da:	50                   	push   %eax
   127db:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
   127de:	50                   	push   %eax
   127df:	8d 45 cc             	lea    0xffffffcc(%ebp),%eax
   127e2:	50                   	push   %eax
   127e3:	56                   	push   %esi
   127e4:	e8 87 08 00 00       	call   13070 <_NdisReadNetworkAddress@16>
   127e9:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   127ec:	85 c0                	test   %eax,%eax
   127ee:	75 06                	jne    127f6 <_MiniportInitialize@24+0x276>
   127f0:	83 7d d0 06          	cmpl   $0x6,0xffffffd0(%ebp)
   127f4:	74 5e                	je     12854 <_MiniportInitialize@24+0x2d4>
   127f6:	83 ec 0c             	sub    $0xc,%esp
   127f9:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
   127fc:	56                   	push   %esi
   127fd:	e8 7e 08 00 00       	call   13080 <_NdisCloseConfiguration@4>
   12802:	83 c4 0c             	add    $0xc,%esp
   12805:	e9 4f fe ff ff       	jmp    12659 <_MiniportInitialize@24+0xd9>
   1280a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1280d:	83 ec 0c             	sub    $0xc,%esp
   12810:	c6 80 4d 02 00 00 01 	movb   $0x1,0x24d(%eax)
   12817:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1281a:	50                   	push   %eax
   1281b:	e8 90 eb ff ff       	call   113b0 <_NICStart>
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   12820:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   12823:	8b 15 0c 60 01 00    	mov    0x1600c,%edx
   12829:	83 c4 10             	add    $0x10,%esp
   1282c:	31 c9                	xor    %ecx,%ecx
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   1282e:	c7 00 08 60 01 00    	movl   $0x16008,(%eax)
	Entry->Blink = OldBlink;
   12834:	89 50 04             	mov    %edx,0x4(%eax)
	OldBlink->Flink = Entry;
   12837:	89 02                	mov    %eax,(%edx)
	ListHead->Blink = Entry;
   12839:	a3 0c 60 01 00       	mov    %eax,0x1600c
   1283e:	e9 9c fd ff ff       	jmp    125df <_MiniportInitialize@24+0x5f>
   12843:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   12846:	8b 50 04             	mov    0x4(%eax),%edx
   12849:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1284c:	89 50 5c             	mov    %edx,0x5c(%eax)
   1284f:	e9 4e ff ff ff       	jmp    127a2 <_MiniportInitialize@24+0x222>
   12854:	31 c9                	xor    %ecx,%ecx
   12856:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   12859:	8b 14 88             	mov    (%eax,%ecx,4),%edx
   1285c:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1285f:	88 94 08 86 00 00 00 	mov    %dl,0x86(%eax,%ecx,1)
   12866:	41                   	inc    %ecx
   12867:	83 f9 05             	cmp    $0x5,%ecx
   1286a:	7e ea                	jle    12856 <_MiniportInitialize@24+0x2d6>
   1286c:	eb 88                	jmp    127f6 <_MiniportInitialize@24+0x276>
   1286e:	89 f6                	mov    %esi,%esi

00012870 <_MiniportISR@12>:
   12870:	55                   	push   %ebp
   12871:	89 e5                	mov    %esp,%ebp
   12873:	83 ec 10             	sub    $0x10,%esp
   12876:	8b 45 10             	mov    0x10(%ebp),%eax
   12879:	6a 00                	push   $0x0
   1287b:	8b 40 60             	mov    0x60(%eax),%eax
   1287e:	83 c0 0f             	add    $0xf,%eax
   12881:	50                   	push   %eax
   12882:	e8 69 08 00 00       	call   130f0 <_WRITE_PORT_UCHAR@8>
   12887:	8b 45 08             	mov    0x8(%ebp),%eax
   1288a:	c6 00 01             	movb   $0x1,(%eax)
   1288d:	8b 45 0c             	mov    0xc(%ebp),%eax
   12890:	c6 00 01             	movb   $0x1,(%eax)
   12893:	c9                   	leave  
   12894:	c2 0c 00             	ret    $0xc
   12897:	89 f6                	mov    %esi,%esi
   12899:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000128a0 <_MiniportQueryInformation@24>:
   128a0:	55                   	push   %ebp
   128a1:	89 e5                	mov    %esp,%ebp
   128a3:	57                   	push   %edi
   128a4:	56                   	push   %esi
   128a5:	53                   	push   %ebx
   128a6:	83 ec 1c             	sub    $0x1c,%esp
   128a9:	31 f6                	xor    %esi,%esi
   128ab:	8b 45 0c             	mov    0xc(%ebp),%eax
   128ae:	8b 4d 08             	mov    0x8(%ebp),%ecx
   128b1:	8b 55 14             	mov    0x14(%ebp),%edx
   128b4:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   128bb:	8d 7d f0             	lea    0xfffffff0(%ebp),%edi
   128be:	bb 04 00 00 00       	mov    $0x4,%ebx
   128c3:	3d 0e 01 01 00       	cmp    $0x1010e,%eax
   128c8:	0f 84 93 00 00 00    	je     12961 <_MiniportQueryInformation@24+0xc1>
   128ce:	77 42                	ja     12912 <_MiniportQueryInformation@24+0x72>
   128d0:	3d 07 01 01 00       	cmp    $0x10107,%eax
   128d5:	0f 84 55 01 00 00    	je     12a30 <_MiniportQueryInformation@24+0x190>
   128db:	0f 87 df 00 00 00    	ja     129c0 <_MiniportQueryInformation@24+0x120>
   128e1:	3d 04 01 01 00       	cmp    $0x10104,%eax
   128e6:	0f 87 50 01 00 00    	ja     12a3c <_MiniportQueryInformation@24+0x19c>
   128ec:	3d 03 01 01 00       	cmp    $0x10103,%eax
   128f1:	0f 83 e3 01 00 00    	jae    12ada <_MiniportQueryInformation@24+0x23a>
   128f7:	3d 01 01 01 00       	cmp    $0x10101,%eax
   128fc:	0f 84 86 02 00 00    	je     12b88 <_MiniportQueryInformation@24+0x2e8>
   12902:	3d 02 01 01 00       	cmp    $0x10102,%eax
   12907:	75 47                	jne    12950 <_MiniportQueryInformation@24+0xb0>
   12909:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   12910:	eb 58                	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12912:	3d 15 01 01 00       	cmp    $0x10115,%eax
   12917:	0f 84 03 01 00 00    	je     12a20 <_MiniportQueryInformation@24+0x180>
   1291d:	0f 87 c4 00 00 00    	ja     129e7 <_MiniportQueryInformation@24+0x147>
   12923:	3d 11 01 01 00       	cmp    $0x10111,%eax
   12928:	0f 84 d3 01 00 00    	je     12b01 <_MiniportQueryInformation@24+0x261>
   1292e:	0f 87 2a 01 00 00    	ja     12a5e <_MiniportQueryInformation@24+0x1be>
   12934:	3d 0f 01 01 00       	cmp    $0x1010f,%eax
   12939:	0f 84 f9 01 00 00    	je     12b38 <_MiniportQueryInformation@24+0x298>
   1293f:	3d 10 01 01 00       	cmp    $0x10110,%eax
   12944:	0f 84 a4 01 00 00    	je     12aee <_MiniportQueryInformation@24+0x24e>
   1294a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12950:	be 17 00 01 c0       	mov    $0xc0010017,%esi
   12955:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12958:	89 f0                	mov    %esi,%eax
   1295a:	5b                   	pop    %ebx
   1295b:	5e                   	pop    %esi
   1295c:	5f                   	pop    %edi
   1295d:	5d                   	pop    %ebp
   1295e:	c2 18 00             	ret    $0x18
   12961:	8b 81 d0 00 00 00    	mov    0xd0(%ecx),%eax
   12967:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1296a:	39 d3                	cmp    %edx,%ebx
   1296c:	76 22                	jbe    12990 <_MiniportQueryInformation@24+0xf0>
   1296e:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12971:	29 d3                	sub    %edx,%ebx
   12973:	be 14 00 01 c0       	mov    $0xc0010014,%esi
   12978:	89 18                	mov    %ebx,(%eax)
   1297a:	8b 5d 18             	mov    0x18(%ebp),%ebx
   1297d:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)
   12983:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12986:	89 f0                	mov    %esi,%eax
   12988:	5b                   	pop    %ebx
   12989:	5e                   	pop    %esi
   1298a:	5f                   	pop    %edi
   1298b:	5d                   	pop    %ebp
   1298c:	c2 18 00             	ret    $0x18
   1298f:	90                   	nop    
   12990:	50                   	push   %eax
   12991:	53                   	push   %ebx
   12992:	57                   	push   %edi
   12993:	8b 7d 10             	mov    0x10(%ebp),%edi
   12996:	57                   	push   %edi
   12997:	e8 44 07 00 00       	call   130e0 <_memcpy>
   1299c:	8b 45 18             	mov    0x18(%ebp),%eax
   1299f:	83 c4 10             	add    $0x10,%esp
   129a2:	89 18                	mov    %ebx,(%eax)
   129a4:	8b 5d 1c             	mov    0x1c(%ebp),%ebx
   129a7:	89 f0                	mov    %esi,%eax
   129a9:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)
   129af:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   129b2:	5b                   	pop    %ebx
   129b3:	5e                   	pop    %esi
   129b4:	5f                   	pop    %edi
   129b5:	5d                   	pop    %ebp
   129b6:	c2 18 00             	ret    $0x18
   129b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   129c0:	3d 0a 01 01 00       	cmp    $0x1010a,%eax
   129c5:	74 17                	je     129de <_MiniportQueryInformation@24+0x13e>
   129c7:	0f 86 d2 00 00 00    	jbe    12a9f <_MiniportQueryInformation@24+0x1ff>
   129cd:	3d 0c 01 01 00       	cmp    $0x1010c,%eax
   129d2:	0f 84 76 01 00 00    	je     12b4e <_MiniportQueryInformation@24+0x2ae>
   129d8:	0f 87 3f 01 00 00    	ja     12b1d <_MiniportQueryInformation@24+0x27d>
   129de:	c7 45 f0 00 01 00 00 	movl   $0x100,0xfffffff0(%ebp)
   129e5:	eb 83                	jmp    1296a <_MiniportQueryInformation@24+0xca>
   129e7:	3d 02 01 01 01       	cmp    $0x1010102,%eax
   129ec:	0f 84 1b 01 00 00    	je     12b0d <_MiniportQueryInformation@24+0x26d>
   129f2:	0f 86 81 00 00 00    	jbe    12a79 <_MiniportQueryInformation@24+0x1d9>
   129f8:	3d 04 01 01 01       	cmp    $0x1010104,%eax
   129fd:	0f 84 40 01 00 00    	je     12b43 <_MiniportQueryInformation@24+0x2a3>
   12a03:	72 6a                	jb     12a6f <_MiniportQueryInformation@24+0x1cf>
   12a05:	be bb 00 00 c0       	mov    $0xc00000bb,%esi
   12a0a:	3d 05 01 01 01       	cmp    $0x1010105,%eax
   12a0f:	0f 84 6e ff ff ff    	je     12983 <_MiniportQueryInformation@24+0xe3>
   12a15:	be 17 00 01 c0       	mov    $0xc0010017,%esi
   12a1a:	e9 36 ff ff ff       	jmp    12955 <_MiniportQueryInformation@24+0xb5>
   12a1f:	90                   	nop    
   12a20:	c7 45 f0 01 00 00 00 	movl   $0x1,0xfffffff0(%ebp)
   12a27:	e9 3e ff ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12a2c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12a30:	c7 45 f0 a0 86 01 00 	movl   $0x186a0,0xfffffff0(%ebp)
   12a37:	e9 2e ff ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12a3c:	3d 05 01 01 00       	cmp    $0x10105,%eax
   12a41:	0f 84 9b 00 00 00    	je     12ae2 <_MiniportQueryInformation@24+0x242>
   12a47:	3d 06 01 01 00       	cmp    $0x10106,%eax
   12a4c:	0f 85 fe fe ff ff    	jne    12950 <_MiniportQueryInformation@24+0xb0>
   12a52:	c7 45 f0 dc 05 00 00 	movl   $0x5dc,0xfffffff0(%ebp)
   12a59:	e9 0c ff ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12a5e:	3d 13 01 01 00       	cmp    $0x10113,%eax
   12a63:	0f 84 c3 00 00 00    	je     12b2c <_MiniportQueryInformation@24+0x28c>
   12a69:	0f 87 9a fe ff ff    	ja     12909 <_MiniportQueryInformation@24+0x69>
   12a6f:	be bb 00 00 c0       	mov    $0xc00000bb,%esi
   12a74:	e9 0a ff ff ff       	jmp    12983 <_MiniportQueryInformation@24+0xe3>
   12a79:	3d 16 01 01 00       	cmp    $0x10116,%eax
   12a7e:	0f 84 eb 00 00 00    	je     12b6f <_MiniportQueryInformation@24+0x2cf>
   12a84:	3d 01 01 01 01       	cmp    $0x1010101,%eax
   12a89:	0f 85 c1 fe ff ff    	jne    12950 <_MiniportQueryInformation@24+0xb0>
   12a8f:	8d b9 80 00 00 00    	lea    0x80(%ecx),%edi
   12a95:	bb 06 00 00 00       	mov    $0x6,%ebx
   12a9a:	e9 cb fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12a9f:	3d 08 01 01 00       	cmp    $0x10108,%eax
   12aa4:	0f 84 d0 00 00 00    	je     12b7a <_MiniportQueryInformation@24+0x2da>
   12aaa:	3d 09 01 01 00       	cmp    $0x10109,%eax
   12aaf:	0f 85 9b fe ff ff    	jne    12950 <_MiniportQueryInformation@24+0xb0>
   12ab5:	8b 41 6c             	mov    0x6c(%ecx),%eax
   12ab8:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   12abb:	8b 41 68             	mov    0x68(%ecx),%eax
   12abe:	29 45 e4             	sub    %eax,0xffffffe4(%ebp)
   12ac1:	8b 81 f8 01 00 00    	mov    0x1f8(%ecx),%eax
   12ac7:	c1 e0 08             	shl    $0x8,%eax
   12aca:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   12acd:	29 c1                	sub    %eax,%ecx
   12acf:	89 4d e4             	mov    %ecx,0xffffffe4(%ebp)
   12ad2:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12ad5:	e9 8d fe ff ff       	jmp    12967 <_MiniportQueryInformation@24+0xc7>
   12ada:	8d 7d ec             	lea    0xffffffec(%ebp),%edi
   12add:	e9 88 fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12ae2:	c7 45 f0 ee 00 00 00 	movl   $0xee,0xfffffff0(%ebp)
   12ae9:	e9 7c fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12aee:	66 c7 45 ea 00 03    	movw   $0x300,0xffffffea(%ebp)
   12af4:	8d 7d ea             	lea    0xffffffea(%ebp),%edi
   12af7:	bb 02 00 00 00       	mov    $0x2,%ebx
   12afc:	e9 69 fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12b01:	c7 45 f0 ea 05 00 00 	movl   $0x5ea,0xfffffff0(%ebp)
   12b08:	e9 5d fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12b0d:	8d b9 86 00 00 00    	lea    0x86(%ecx),%edi
   12b13:	bb 06 00 00 00       	mov    $0x6,%ebx
   12b18:	e9 4d fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12b1d:	bf d2 50 01 00       	mov    $0x150d2,%edi
   12b22:	bb 1b 00 00 00       	mov    $0x1b,%ebx
   12b27:	e9 3e fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12b2c:	c7 45 f0 0f 00 00 00 	movl   $0xf,0xfffffff0(%ebp)
   12b33:	e9 32 fe ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12b38:	8b 81 d4 00 00 00    	mov    0xd4(%ecx),%eax
   12b3e:	e9 24 fe ff ff       	jmp    12967 <_MiniportQueryInformation@24+0xc7>
   12b43:	8b 81 8c 00 00 00    	mov    0x8c(%ecx),%eax
   12b49:	e9 19 fe ff ff       	jmp    12967 <_MiniportQueryInformation@24+0xc7>
   12b4e:	66 8b 81 80 00 00 00 	mov    0x80(%ecx),%ax
   12b55:	66 89 45 f0          	mov    %ax,0xfffffff0(%ebp)
   12b59:	8a 81 82 00 00 00    	mov    0x82(%ecx),%al
   12b5f:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   12b62:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   12b65:	30 c0                	xor    %al,%al
   12b67:	83 c8 01             	or     $0x1,%eax
   12b6a:	e9 f8 fd ff ff       	jmp    12967 <_MiniportQueryInformation@24+0xc7>
   12b6f:	66 c7 45 ea 00 01    	movw   $0x100,0xffffffea(%ebp)
   12b75:	e9 7a ff ff ff       	jmp    12af4 <_MiniportQueryInformation@24+0x254>
   12b7a:	8b 81 f8 01 00 00    	mov    0x1f8(%ecx),%eax
   12b80:	c1 e0 08             	shl    $0x8,%eax
   12b83:	e9 df fd ff ff       	jmp    12967 <_MiniportQueryInformation@24+0xc7>
   12b88:	bf 40 40 01 00       	mov    $0x14040,%edi
   12b8d:	bb 6c 00 00 00       	mov    $0x6c,%ebx
   12b92:	e9 d3 fd ff ff       	jmp    1296a <_MiniportQueryInformation@24+0xca>
   12b97:	89 f6                	mov    %esi,%esi
   12b99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012ba0 <_MiniportReconfigure@12>:
   12ba0:	55                   	push   %ebp
   12ba1:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12ba6:	89 e5                	mov    %esp,%ebp
   12ba8:	5d                   	pop    %ebp
   12ba9:	c2 0c 00             	ret    $0xc
   12bac:	8d 74 26 00          	lea    0x0(%esi),%esi

00012bb0 <_MiniportReset@8>:
   12bb0:	55                   	push   %ebp
   12bb1:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12bb6:	89 e5                	mov    %esp,%ebp
   12bb8:	5d                   	pop    %ebp
   12bb9:	c2 08 00             	ret    $0x8
   12bbc:	8d 74 26 00          	lea    0x0(%esi),%esi

00012bc0 <_MiniportSend@12>:
   12bc0:	55                   	push   %ebp
   12bc1:	89 e5                	mov    %esp,%ebp
   12bc3:	52                   	push   %edx
   12bc4:	52                   	push   %edx
   12bc5:	8b 55 0c             	mov    0xc(%ebp),%edx
   12bc8:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12bcb:	c7 42 20 00 00 00 00 	movl   $0x0,0x20(%edx)
   12bd2:	8b 81 38 02 00 00    	mov    0x238(%ecx),%eax
   12bd8:	85 c0                	test   %eax,%eax
   12bda:	75 24                	jne    12c00 <_MiniportSend@12+0x40>
   12bdc:	83 ec 0c             	sub    $0xc,%esp
   12bdf:	89 91 38 02 00 00    	mov    %edx,0x238(%ecx)
   12be5:	89 91 3c 02 00 00    	mov    %edx,0x23c(%ecx)
   12beb:	51                   	push   %ecx
   12bec:	e8 6f f4 ff ff       	call   12060 <_NICTransmit>
   12bf1:	b8 03 01 00 00       	mov    $0x103,%eax
   12bf6:	c9                   	leave  
   12bf7:	c2 0c 00             	ret    $0xc
   12bfa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12c00:	8b 81 3c 02 00 00    	mov    0x23c(%ecx),%eax
   12c06:	83 ec 0c             	sub    $0xc,%esp
   12c09:	89 50 20             	mov    %edx,0x20(%eax)
   12c0c:	89 91 3c 02 00 00    	mov    %edx,0x23c(%ecx)
   12c12:	51                   	push   %ecx
   12c13:	e8 48 f4 ff ff       	call   12060 <_NICTransmit>
   12c18:	b8 03 01 00 00       	mov    $0x103,%eax
   12c1d:	c9                   	leave  
   12c1e:	c2 0c 00             	ret    $0xc
   12c21:	eb 0d                	jmp    12c30 <_MiniportSetInformation@24>
   12c23:	90                   	nop    
   12c24:	90                   	nop    
   12c25:	90                   	nop    
   12c26:	90                   	nop    
   12c27:	90                   	nop    
   12c28:	90                   	nop    
   12c29:	90                   	nop    
   12c2a:	90                   	nop    
   12c2b:	90                   	nop    
   12c2c:	90                   	nop    
   12c2d:	90                   	nop    
   12c2e:	90                   	nop    
   12c2f:	90                   	nop    

00012c30 <_MiniportSetInformation@24>:
   12c30:	55                   	push   %ebp
   12c31:	89 e5                	mov    %esp,%ebp
   12c33:	57                   	push   %edi
   12c34:	56                   	push   %esi
   12c35:	53                   	push   %ebx
   12c36:	83 ec 0c             	sub    $0xc,%esp
   12c39:	31 db                	xor    %ebx,%ebx
   12c3b:	8b 45 0c             	mov    0xc(%ebp),%eax
   12c3e:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12c41:	8b 75 18             	mov    0x18(%ebp),%esi
   12c44:	3d 0f 01 01 00       	cmp    $0x1010f,%eax
   12c49:	74 65                	je     12cb0 <_MiniportSetInformation@24+0x80>
   12c4b:	76 2b                	jbe    12c78 <_MiniportSetInformation@24+0x48>
   12c4d:	3d 03 01 01 01       	cmp    $0x1010103,%eax
   12c52:	0f 84 a8 00 00 00    	je     12d00 <_MiniportSetInformation@24+0xd0>
   12c58:	8b 55 1c             	mov    0x1c(%ebp),%edx
   12c5b:	c7 06 00 00 00 00    	movl   $0x0,(%esi)
   12c61:	bb 17 00 01 c0       	mov    $0xc0010017,%ebx
   12c66:	c7 02 00 00 00 00    	movl   $0x0,(%edx)
   12c6c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12c6f:	89 d8                	mov    %ebx,%eax
   12c71:	5b                   	pop    %ebx
   12c72:	5e                   	pop    %esi
   12c73:	5f                   	pop    %edi
   12c74:	5d                   	pop    %ebp
   12c75:	c2 18 00             	ret    $0x18
   12c78:	3d 0e 01 01 00       	cmp    $0x1010e,%eax
   12c7d:	75 d9                	jne    12c58 <_MiniportSetInformation@24+0x28>
   12c7f:	83 7d 14 03          	cmpl   $0x3,0x14(%ebp)
   12c83:	0f 87 a0 00 00 00    	ja     12d29 <_MiniportSetInformation@24+0xf9>
   12c89:	c7 06 00 00 00 00    	movl   $0x0,(%esi)
   12c8f:	b8 04 00 00 00       	mov    $0x4,%eax
   12c94:	8b 5d 14             	mov    0x14(%ebp),%ebx
   12c97:	8b 55 1c             	mov    0x1c(%ebp),%edx
   12c9a:	29 d8                	sub    %ebx,%eax
   12c9c:	89 02                	mov    %eax,(%edx)
   12c9e:	bb 14 00 01 c0       	mov    $0xc0010014,%ebx
   12ca3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12ca6:	89 d8                	mov    %ebx,%eax
   12ca8:	5b                   	pop    %ebx
   12ca9:	5e                   	pop    %esi
   12caa:	5f                   	pop    %edi
   12cab:	5d                   	pop    %ebp
   12cac:	c2 18 00             	ret    $0x18
   12caf:	90                   	nop    
   12cb0:	83 7d 14 03          	cmpl   $0x3,0x14(%ebp)
   12cb4:	76 2c                	jbe    12ce2 <_MiniportSetInformation@24+0xb2>
   12cb6:	8b 01                	mov    (%ecx),%eax
   12cb8:	3d ee 00 00 00       	cmp    $0xee,%eax
   12cbd:	77 df                	ja     12c9e <_MiniportSetInformation@24+0x6e>
   12cbf:	8b 55 08             	mov    0x8(%ebp),%edx
   12cc2:	89 82 d4 00 00 00    	mov    %eax,0xd4(%edx)
   12cc8:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12ccb:	8b 7d 14             	mov    0x14(%ebp),%edi
   12cce:	89 3e                	mov    %edi,(%esi)
   12cd0:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12cd6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12cd9:	89 d8                	mov    %ebx,%eax
   12cdb:	5b                   	pop    %ebx
   12cdc:	5e                   	pop    %esi
   12cdd:	5f                   	pop    %edi
   12cde:	5d                   	pop    %ebp
   12cdf:	c2 18 00             	ret    $0x18
   12ce2:	c7 06 00 00 00 00    	movl   $0x0,(%esi)
   12ce8:	b8 04 00 00 00       	mov    $0x4,%eax
   12ced:	8b 4d 14             	mov    0x14(%ebp),%ecx
   12cf0:	8b 7d 1c             	mov    0x1c(%ebp),%edi
   12cf3:	29 c8                	sub    %ecx,%eax
   12cf5:	bb 14 00 01 c0       	mov    $0xc0010014,%ebx
   12cfa:	89 07                	mov    %eax,(%edi)
   12cfc:	eb a5                	jmp    12ca3 <_MiniportSetInformation@24+0x73>
   12cfe:	89 f6                	mov    %esi,%esi
   12d00:	31 d2                	xor    %edx,%edx
   12d02:	8b 45 14             	mov    0x14(%ebp),%eax
   12d05:	bf 06 00 00 00       	mov    $0x6,%edi
   12d0a:	f7 f7                	div    %edi
   12d0c:	85 d2                	test   %edx,%edx
   12d0e:	74 49                	je     12d59 <_MiniportSetInformation@24+0x129>
   12d10:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12d13:	bb 14 00 01 c0       	mov    $0xc0010014,%ebx
   12d18:	c7 06 00 00 00 00    	movl   $0x0,(%esi)
   12d1e:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12d24:	e9 7a ff ff ff       	jmp    12ca3 <_MiniportSetInformation@24+0x73>
   12d29:	8b 01                	mov    (%ecx),%eax
   12d2b:	a9 50 f0 00 00       	test   $0xf050,%eax
   12d30:	74 19                	je     12d4b <_MiniportSetInformation@24+0x11b>
   12d32:	8b 7d 1c             	mov    0x1c(%ebp),%edi
   12d35:	bb bb 00 00 c0       	mov    $0xc00000bb,%ebx
   12d3a:	c7 06 04 00 00 00    	movl   $0x4,(%esi)
   12d40:	c7 07 00 00 00 00    	movl   $0x0,(%edi)
   12d46:	e9 21 ff ff ff       	jmp    12c6c <_MiniportSetInformation@24+0x3c>
   12d4b:	8b 55 08             	mov    0x8(%ebp),%edx
   12d4e:	89 82 d0 00 00 00    	mov    %eax,0xd0(%edx)
   12d54:	e9 6f ff ff ff       	jmp    12cc8 <_MiniportSetInformation@24+0x98>
   12d59:	8b 45 08             	mov    0x8(%ebp),%eax
   12d5c:	52                   	push   %edx
   12d5d:	05 90 00 00 00       	add    $0x90,%eax
   12d62:	8b 7d 14             	mov    0x14(%ebp),%edi
   12d65:	57                   	push   %edi
   12d66:	51                   	push   %ecx
   12d67:	50                   	push   %eax
   12d68:	e8 73 03 00 00       	call   130e0 <_memcpy>
   12d6d:	83 c4 10             	add    $0x10,%esp
   12d70:	e9 53 ff ff ff       	jmp    12cc8 <_MiniportSetInformation@24+0x98>
   12d75:	8d 74 26 00          	lea    0x0(%esi),%esi
   12d79:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012d80 <_MiniportTransferData@24>:
   12d80:	55                   	push   %ebp
   12d81:	89 e5                	mov    %esp,%ebp
   12d83:	57                   	push   %edi
   12d84:	56                   	push   %esi
   12d85:	53                   	push   %ebx
   12d86:	83 ec 1c             	sub    $0x1c,%esp
   12d89:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12d8c:	8b 5d 18             	mov    0x18(%ebp),%ebx
   12d8f:	85 c0                	test   %eax,%eax
   12d91:	75 15                	jne    12da8 <_MiniportTransferData@24+0x28>
   12d93:	8b 45 0c             	mov    0xc(%ebp),%eax
   12d96:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12d9c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12d9f:	31 c0                	xor    %eax,%eax
   12da1:	5b                   	pop    %ebx
   12da2:	5e                   	pop    %esi
   12da3:	5f                   	pop    %edi
   12da4:	5d                   	pop    %ebp
   12da5:	c2 18 00             	ret    $0x18
   12da8:	8b 55 10             	mov    0x10(%ebp),%edx
   12dab:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12dae:	8b 45 08             	mov    0x8(%ebp),%eax
   12db1:	8b 92 d4 01 00 00    	mov    0x1d4(%edx),%edx
   12db7:	8b 89 d8 01 00 00    	mov    0x1d8(%ecx),%ecx
   12dbd:	c1 e2 08             	shl    $0x8,%edx
   12dc0:	8b 40 08             	mov    0x8(%eax),%eax
   12dc3:	c1 e1 08             	shl    $0x8,%ecx
   12dc6:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   12dc9:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
   12dcc:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12dcf:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   12dd2:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
   12dd5:	57                   	push   %edi
   12dd6:	50                   	push   %eax
   12dd7:	52                   	push   %edx
   12dd8:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
   12ddb:	56                   	push   %esi
   12ddc:	e8 bf 01 00 00       	call   12fa0 <_NdisQueryBuffer@12>
   12de1:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12de4:	8b 81 ec 01 00 00    	mov    0x1ec(%ecx),%eax
   12dea:	01 d8                	add    %ebx,%eax
   12dec:	8d 78 12             	lea    0x12(%eax),%edi
   12def:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12df2:	8d 54 03 12          	lea    0x12(%ebx,%eax,1),%edx
   12df6:	66 8b 81 ea 01 00 00 	mov    0x1ea(%ecx),%ax
   12dfd:	25 ff ff 00 00       	and    $0xffff,%eax
   12e02:	59                   	pop    %ecx
   12e03:	39 c2                	cmp    %eax,%edx
   12e05:	0f 87 88 00 00 00    	ja     12e93 <_MiniportTransferData@24+0x113>
   12e0b:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   12e12:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   12e15:	8b 5d 1c             	mov    0x1c(%ebp),%ebx
   12e18:	39 c3                	cmp    %eax,%ebx
   12e1a:	76 02                	jbe    12e1e <_MiniportTransferData@24+0x9e>
   12e1c:	89 c3                	mov    %eax,%ebx
   12e1e:	8d 34 1f             	lea    (%edi,%ebx,1),%esi
   12e21:	3b 75 dc             	cmp    0xffffffdc(%ebp),%esi
   12e24:	76 08                	jbe    12e2e <_MiniportTransferData@24+0xae>
   12e26:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
   12e29:	29 fb                	sub    %edi,%ebx
   12e2b:	8d 34 1f             	lea    (%edi,%ebx,1),%esi
   12e2e:	89 d8                	mov    %ebx,%eax
   12e30:	25 ff ff 00 00       	and    $0xffff,%eax
   12e35:	50                   	push   %eax
   12e36:	57                   	push   %edi
   12e37:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12e3a:	50                   	push   %eax
   12e3b:	8b 45 10             	mov    0x10(%ebp),%eax
   12e3e:	50                   	push   %eax
   12e3f:	e8 7c ec ff ff       	call   11ac0 <_NICReadData>
   12e44:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
   12e47:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   12e4a:	01 df                	add    %ebx,%edi
   12e4c:	01 d9                	add    %ebx,%ecx
   12e4e:	83 c4 10             	add    $0x10,%esp
   12e51:	29 5d 1c             	sub    %ebx,0x1c(%ebp)
   12e54:	89 7d e4             	mov    %edi,0xffffffe4(%ebp)
   12e57:	89 4d ec             	mov    %ecx,0xffffffec(%ebp)
   12e5a:	89 f7                	mov    %esi,%edi
   12e5c:	74 42                	je     12ea0 <_MiniportTransferData@24+0x120>
   12e5e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   12e61:	29 d8                	sub    %ebx,%eax
   12e63:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12e66:	85 c0                	test   %eax,%eax
   12e68:	75 1f                	jne    12e89 <_MiniportTransferData@24+0x109>
   12e6a:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   12e6d:	8b 02                	mov    (%edx),%eax
   12e6f:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12e72:	85 c0                	test   %eax,%eax
   12e74:	74 2a                	je     12ea0 <_MiniportTransferData@24+0x120>
   12e76:	8d 4d f0             	lea    0xfffffff0(%ebp),%ecx
   12e79:	52                   	push   %edx
   12e7a:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
   12e7d:	51                   	push   %ecx
   12e7e:	52                   	push   %edx
   12e7f:	50                   	push   %eax
   12e80:	e8 1b 01 00 00       	call   12fa0 <_NdisQueryBuffer@12>
   12e85:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   12e88:	5e                   	pop    %esi
   12e89:	3b 7d dc             	cmp    0xffffffdc(%ebp),%edi
   12e8c:	75 87                	jne    12e15 <_MiniportTransferData@24+0x95>
   12e8e:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
   12e91:	eb 82                	jmp    12e15 <_MiniportTransferData@24+0x95>
   12e93:	29 d8                	sub    %ebx,%eax
   12e95:	83 e8 12             	sub    $0x12,%eax
   12e98:	89 45 1c             	mov    %eax,0x1c(%ebp)
   12e9b:	e9 6b ff ff ff       	jmp    12e0b <_MiniportTransferData@24+0x8b>
   12ea0:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12ea3:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12ea6:	89 01                	mov    %eax,(%ecx)
   12ea8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12eab:	31 c0                	xor    %eax,%eax
   12ead:	5b                   	pop    %ebx
   12eae:	5e                   	pop    %esi
   12eaf:	5f                   	pop    %edi
   12eb0:	5d                   	pop    %ebp
   12eb1:	c2 18 00             	ret    $0x18
   12eb4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12eba:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00012ec0 <_DriverEntry@8>:
   12ec0:	55                   	push   %ebp
   12ec1:	89 e5                	mov    %esp,%ebp
   12ec3:	53                   	push   %ebx
   12ec4:	83 ec 5c             	sub    $0x5c,%esp
   12ec7:	8d 5d b8             	lea    0xffffffb8(%ebp),%ebx
   12eca:	6a 3c                	push   $0x3c
   12ecc:	53                   	push   %ebx
   12ecd:	e8 fe 01 00 00       	call   130d0 <_RtlZeroMemory@8>
   12ed2:	c6 45 b8 03          	movb   $0x3,0xffffffb8(%ebp)
   12ed6:	58                   	pop    %eax
   12ed7:	8b 45 0c             	mov    0xc(%ebp),%eax
   12eda:	5a                   	pop    %edx
   12edb:	c6 45 b9 00          	movb   $0x0,0xffffffb9(%ebp)
   12edf:	6a 00                	push   $0x0
   12ee1:	50                   	push   %eax
   12ee2:	8b 45 08             	mov    0x8(%ebp),%eax
   12ee5:	c7 45 c0 00 00 00 00 	movl   $0x0,0xffffffc0(%ebp)
   12eec:	50                   	push   %eax
   12eed:	8d 45 b4             	lea    0xffffffb4(%ebp),%eax
   12ef0:	50                   	push   %eax
   12ef1:	c7 45 c4 a0 24 01 00 	movl   $0x124a0,0xffffffc4(%ebp)
   12ef8:	c7 45 c8 c0 24 01 00 	movl   $0x124c0,0xffffffc8(%ebp)
   12eff:	c7 45 cc f0 24 01 00 	movl   $0x124f0,0xffffffcc(%ebp)
   12f06:	c7 45 d0 e0 22 01 00 	movl   $0x122e0,0xffffffd0(%ebp)
   12f0d:	c7 45 d4 80 25 01 00 	movl   $0x12580,0xffffffd4(%ebp)
   12f14:	c7 45 d8 70 28 01 00 	movl   $0x12870,0xffffffd8(%ebp)
   12f1b:	c7 45 dc a0 28 01 00 	movl   $0x128a0,0xffffffdc(%ebp)
   12f22:	c7 45 e0 a0 2b 01 00 	movl   $0x12ba0,0xffffffe0(%ebp)
   12f29:	c7 45 e4 b0 2b 01 00 	movl   $0x12bb0,0xffffffe4(%ebp)
   12f30:	c7 45 e8 c0 2b 01 00 	movl   $0x12bc0,0xffffffe8(%ebp)
   12f37:	c7 45 ec 30 2c 01 00 	movl   $0x12c30,0xffffffec(%ebp)
   12f3e:	c7 45 f0 80 2d 01 00 	movl   $0x12d80,0xfffffff0(%ebp)
   12f45:	e8 46 01 00 00       	call   13090 <_NdisInitializeWrapper@16>
   12f4a:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
   12f4d:	c7 05 04 60 01 00 00 	movl   $0x0,0x16004
   12f54:	00 00 00 
   12f57:	51                   	push   %ecx
   12f58:	a3 00 60 01 00       	mov    %eax,0x16000
   12f5d:	6a 3c                	push   $0x3c
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   12f5f:	c7 05 0c 60 01 00 08 	movl   $0x16008,0x1600c
   12f66:	60 01 00 
   12f69:	53                   	push   %ebx
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   12f6a:	c7 05 08 60 01 00 08 	movl   $0x16008,0x16008
   12f71:	60 01 00 
   12f74:	50                   	push   %eax
   12f75:	e8 26 01 00 00       	call   130a0 <_NdisMRegisterMiniport@12>
   12f7a:	5a                   	pop    %edx
   12f7b:	31 d2                	xor    %edx,%edx
   12f7d:	85 c0                	test   %eax,%eax
   12f7f:	75 09                	jne    12f8a <_DriverEntry@8+0xca>
   12f81:	89 d0                	mov    %edx,%eax
   12f83:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12f86:	c9                   	leave  
   12f87:	c2 08 00             	ret    $0x8
   12f8a:	50                   	push   %eax
   12f8b:	50                   	push   %eax
   12f8c:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
   12f8f:	6a 00                	push   $0x0
   12f91:	50                   	push   %eax
   12f92:	e8 19 01 00 00       	call   130b0 <_NdisTerminateWrapper@8>
   12f97:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12f9c:	eb e3                	jmp    12f81 <_DriverEntry@8+0xc1>
   12f9e:	90                   	nop    
   12f9f:	90                   	nop    

00012fa0 <_NdisQueryBuffer@12>:
   12fa0:	ff 25 3c 71 01 00    	jmp    *0x1713c
   12fa6:	90                   	nop    
   12fa7:	90                   	nop    
	...

00012fb0 <_NDIS_BUFFER_TO_SPAN_PAGES@4>:
   12fb0:	ff 25 08 71 01 00    	jmp    *0x17108
   12fb6:	90                   	nop    
   12fb7:	90                   	nop    
	...

00012fc0 <_NdisQueryBufferOffset@12>:
   12fc0:	ff 25 40 71 01 00    	jmp    *0x17140
   12fc6:	90                   	nop    
   12fc7:	90                   	nop    
	...

00012fd0 <_NdisFreeMemory@12>:
   12fd0:	ff 25 14 71 01 00    	jmp    *0x17114
   12fd6:	90                   	nop    
   12fd7:	90                   	nop    
	...

00012fe0 <_NdisMDeregisterInterrupt@4>:
   12fe0:	ff 25 20 71 01 00    	jmp    *0x17120
   12fe6:	90                   	nop    
   12fe7:	90                   	nop    
	...

00012ff0 <_NdisMDeregisterIoPortRange@16>:
   12ff0:	ff 25 24 71 01 00    	jmp    *0x17124
   12ff6:	90                   	nop    
   12ff7:	90                   	nop    
	...

00013000 <_NdisAllocateMemory@20>:
   13000:	ff 25 0c 71 01 00    	jmp    *0x1710c
   13006:	90                   	nop    
   13007:	90                   	nop    
	...

00013010 <_NdisOpenConfiguration@12>:
   13010:	ff 25 38 71 01 00    	jmp    *0x17138
   13016:	90                   	nop    
   13017:	90                   	nop    
	...

00013020 <_NdisMSetAttributes@16>:
   13020:	ff 25 34 71 01 00    	jmp    *0x17134
   13026:	90                   	nop    
   13027:	90                   	nop    
	...

00013030 <_NdisMRegisterIoPortRange@16>:
   13030:	ff 25 2c 71 01 00    	jmp    *0x1712c
   13036:	90                   	nop    
   13037:	90                   	nop    
	...

00013040 <_NdisMRegisterInterrupt@28>:
   13040:	ff 25 28 71 01 00    	jmp    *0x17128
   13046:	90                   	nop    
   13047:	90                   	nop    
	...

00013050 <_NdisInitUnicodeString@8>:
   13050:	ff 25 18 71 01 00    	jmp    *0x17118
   13056:	90                   	nop    
   13057:	90                   	nop    
	...

00013060 <_NdisReadConfiguration@20>:
   13060:	ff 25 44 71 01 00    	jmp    *0x17144
   13066:	90                   	nop    
   13067:	90                   	nop    
	...

00013070 <_NdisReadNetworkAddress@16>:
   13070:	ff 25 48 71 01 00    	jmp    *0x17148
   13076:	90                   	nop    
   13077:	90                   	nop    
	...

00013080 <_NdisCloseConfiguration@4>:
   13080:	ff 25 10 71 01 00    	jmp    *0x17110
   13086:	90                   	nop    
   13087:	90                   	nop    
	...

00013090 <_NdisInitializeWrapper@16>:
   13090:	ff 25 1c 71 01 00    	jmp    *0x1711c
   13096:	90                   	nop    
   13097:	90                   	nop    
	...

000130a0 <_NdisMRegisterMiniport@12>:
   130a0:	ff 25 30 71 01 00    	jmp    *0x17130
   130a6:	90                   	nop    
   130a7:	90                   	nop    
	...

000130b0 <_NdisTerminateWrapper@8>:
   130b0:	ff 25 4c 71 01 00    	jmp    *0x1714c
   130b6:	90                   	nop    
   130b7:	90                   	nop    
	...

000130c0 <_DbgPrint>:
   130c0:	ff 25 58 71 01 00    	jmp    *0x17158
   130c6:	90                   	nop    
   130c7:	90                   	nop    
	...

000130d0 <_RtlZeroMemory@8>:
   130d0:	ff 25 5c 71 01 00    	jmp    *0x1715c
   130d6:	90                   	nop    
   130d7:	90                   	nop    
	...

000130e0 <_memcpy>:
   130e0:	ff 25 60 71 01 00    	jmp    *0x17160
   130e6:	90                   	nop    
   130e7:	90                   	nop    
	...

000130f0 <_WRITE_PORT_UCHAR@8>:
   130f0:	ff 25 fc 70 01 00    	jmp    *0x170fc
   130f6:	90                   	nop    
   130f7:	90                   	nop    
	...

00013100 <_KeStallExecutionProcessor@4>:
   13100:	ff 25 e0 70 01 00    	jmp    *0x170e0
   13106:	90                   	nop    
   13107:	90                   	nop    
	...

00013110 <_READ_PORT_UCHAR@4>:
   13110:	ff 25 ec 70 01 00    	jmp    *0x170ec
   13116:	90                   	nop    
   13117:	90                   	nop    
	...

00013120 <_READ_PORT_BUFFER_USHORT@12>:
   13120:	ff 25 e8 70 01 00    	jmp    *0x170e8
   13126:	90                   	nop    
   13127:	90                   	nop    
	...

00013130 <_READ_PORT_BUFFER_UCHAR@12>:
   13130:	ff 25 e4 70 01 00    	jmp    *0x170e4
   13136:	90                   	nop    
   13137:	90                   	nop    
	...

00013140 <_READ_PORT_USHORT@4>:
   13140:	ff 25 f0 70 01 00    	jmp    *0x170f0
   13146:	90                   	nop    
   13147:	90                   	nop    
	...

00013150 <_WRITE_PORT_BUFFER_USHORT@12>:
   13150:	ff 25 f8 70 01 00    	jmp    *0x170f8
   13156:	90                   	nop    
   13157:	90                   	nop    
	...

00013160 <_WRITE_PORT_BUFFER_UCHAR@12>:
   13160:	ff 25 f4 70 01 00    	jmp    *0x170f4
   13166:	90                   	nop    
   13167:	90                   	nop    
	...

00013170 <__CTOR_LIST__>:
   13170:	ff                   	(bad)  
   13171:	ff                   	(bad)  
   13172:	ff                   	(bad)  
   13173:	ff 00                	incl   (%eax)
   13175:	00 00                	add    %al,(%eax)
	...

00013178 <__DTOR_LIST__>:
   13178:	ff                   	(bad)  
   13179:	ff                   	(bad)  
   1317a:	ff                   	(bad)  
   1317b:	ff 00                	incl   (%eax)
   1317d:	00 00                	add    %al,(%eax)
	...
