
pcnet.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_MiniportHandleInterrupt@4>:
 *     MiniportAdapterContext: context specified to NdisMSetAttributes
 * NOTES:
 *     - Called by NDIS at DISPATCH_LEVEL
 */
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	57                   	push   %edi
   11004:	56                   	push   %esi
   11005:	53                   	push   %ebx
   11006:	83 ec 0c             	sub    $0xc,%esp
   11009:	8b 75 08             	mov    0x8(%ebp),%esi
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
  USHORT Data;

  PCNET_DbgPrint(("Called\n"));

  NdisDprAcquireSpinLock(&Adapter->Lock);
   1100c:	89 f1                	mov    %esi,%ecx
   1100e:	ff 15 6c 51 01 00    	call   *0x1516c
   11014:	c6 46 04 02          	movb   $0x2,0x4(%esi)

  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
   11018:	50                   	push   %eax
   11019:	50                   	push   %eax
   1101a:	6a 00                	push   $0x0
   1101c:	8b 46 18             	mov    0x18(%esi),%eax
   1101f:	83 c0 12             	add    $0x12,%eax
   11022:	50                   	push   %eax
   11023:	ff 15 04 51 01 00    	call   *0x15104
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
   11029:	50                   	push   %eax
   1102a:	8b 46 18             	mov    0x18(%esi),%eax
   1102d:	83 c0 10             	add    $0x10,%eax
   11030:	50                   	push   %eax
   11031:	ff 15 00 51 01 00    	call   *0x15100
   11037:	89 c7                	mov    %eax,%edi

  PCNET_DbgPrint(("CSR0 is 0x%x\n", Data));

  while(Data & CSR0_INTR)
   11039:	83 c4 0c             	add    $0xc,%esp
    {
      /* Clear interrupt flags early to avoid race conditions. */
      NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);

      if(Data & CSR0_ERR)
        {
          PCNET_DbgPrint(("error: %x\n", Data & (CSR0_MERR|CSR0_BABL|CSR0_CERR|CSR0_MISS)))
          if (Data & CSR0_CERR)
            Adapter->Statistics.XmtCollisions++;
        }
      else if(Data & CSR0_IDON)
        {
          PCNET_DbgPrint(("IDON\n"));
        }
      else if(Data & CSR0_RINT)
        {
          PCNET_DbgPrint(("receive interrupt\n"));

          while(1)
            {
              PRECEIVE_DESCRIPTOR Descriptor = Adapter->ReceiveDescriptorRingVirt + Adapter->CurrentReceiveDescriptorIndex;
              PCHAR Buffer;
              ULONG ByteCount;

              if(Descriptor->FLAGS & RD_OWN)
                {
                  PCNET_DbgPrint(("no more receive descriptors to process\n"));
                  break;
                }

              if(Descriptor->FLAGS & RD_ERR)
                {
                  PCNET_DbgPrint(("receive descriptor error: 0x%x\n", Descriptor->FLAGS));
                  if (Descriptor->FLAGS & RD_BUFF)
                    Adapter->Statistics.RcvBufferErrors++;
                  if (Descriptor->FLAGS & RD_CRC)
                    Adapter->Statistics.RcvCrcErrors++;
                  if (Descriptor->FLAGS & RD_OFLO)
                    Adapter->Statistics.RcvOverflowErrors++;
                  if (Descriptor->FLAGS & RD_FRAM)
                    Adapter->Statistics.RcvFramingErrors++;
                  break;
                }

              if(!((Descriptor->FLAGS & RD_STP) && (Descriptor->FLAGS & RD_ENP)))
                {
                  PCNET_DbgPrint(("receive descriptor not start&end: 0x%x\n", Descriptor->FLAGS));
                  break;
                }

              Buffer = Adapter->ReceiveBufferPtrVirt + Adapter->CurrentReceiveDescriptorIndex * BUFFER_SIZE;
              ByteCount = Descriptor->MCNT & 0xfff;

              PCNET_DbgPrint(("Indicating a %d-byte packet (index %d)\n", ByteCount, Adapter->CurrentReceiveDescriptorIndex));

              NdisMEthIndicateReceive(Adapter->MiniportAdapterHandle, 0, Buffer, 14, Buffer+14, ByteCount-14, ByteCount-14);
              NdisMEthIndicateReceiveComplete(Adapter->MiniportAdapterHandle);

              RtlZeroMemory(Descriptor, sizeof(RECEIVE_DESCRIPTOR));
              Descriptor->RBADR = 
                  (ULONG)(Adapter->ReceiveBufferPtrPhys + Adapter->CurrentReceiveDescriptorIndex * BUFFER_SIZE);
              Descriptor->BCNT = (-BUFFER_SIZE) | 0xf000;
              Descriptor->FLAGS |= RD_OWN;

              Adapter->CurrentReceiveDescriptorIndex++;
              Adapter->CurrentReceiveDescriptorIndex %= NUMBER_OF_BUFFERS;

              Adapter->Statistics.RcvGoodFrames++;
            }
        }
      else if(Data & CSR0_TINT)
        {
          PTRANSMIT_DESCRIPTOR Descriptor;

          PCNET_DbgPrint(("transmit interrupt\n"));

          while (Adapter->CurrentTransmitStartIndex !=
                 Adapter->CurrentTransmitEndIndex)
            {
              Descriptor = Adapter->TransmitDescriptorRingVirt + Adapter->CurrentTransmitStartIndex;

              PCNET_DbgPrint(("buffer %d flags %x flags2 %x\n",
                              Adapter->CurrentTransmitStartIndex,
                              Descriptor->FLAGS, Descriptor->FLAGS2));

              if (Descriptor->FLAGS & TD1_OWN)
                {
                  PCNET_DbgPrint(("non-TXed buffer\n"));
                  break;
                }

              if (Descriptor->FLAGS & TD1_STP)
                {
                  if (Descriptor->FLAGS & TD1_ONE)
                    Adapter->Statistics.XmtOneRetry++;
                  else if (Descriptor->FLAGS & TD1_MORE)
                    Adapter->Statistics.XmtMoreThanOneRetry++;
                }

              if (Descriptor->FLAGS & TD1_ERR)
                {
                  PCNET_DbgPrint(("major error: %x\n", Descriptor->FLAGS2));
                  if (Descriptor->FLAGS2 & TD2_RTRY)
                    Adapter->Statistics.XmtRetryErrors++;
                  if (Descriptor->FLAGS2 & TD2_LCAR)
                    Adapter->Statistics.XmtLossesOfCarrier++;
                  if (Descriptor->FLAGS2 & TD2_LCOL)
                    Adapter->Statistics.XmtLateCollisions++;
                  if (Descriptor->FLAGS2 & TD2_EXDEF)
                    Adapter->Statistics.XmtExcessiveDefferals++;
                  if (Descriptor->FLAGS2 & TD2_UFLO)
                    Adapter->Statistics.XmtBufferUnderflows++;
                  if (Descriptor->FLAGS2 & TD2_BUFF)
                    Adapter->Statistics.XmtBufferErrors++;
                  break;
                }

              Adapter->CurrentTransmitStartIndex++;
              Adapter->CurrentTransmitStartIndex %= NUMBER_OF_BUFFERS;

              Adapter->Statistics.XmtGoodFrames++;
            }
          NdisMSendResourcesAvailable(Adapter->MiniportAdapterHandle);
        }
      else
        {
          PCNET_DbgPrint(("UNHANDLED INTERRUPT\n"));
          ASSERT(FALSE);
        }

      NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
   1103c:	f7 c7 80 00 00 00    	test   $0x80,%edi
   11042:	0f 84 40 01 00 00    	je     11188 <_MiniportHandleInterrupt@4+0x188>
   11048:	89 fb                	mov    %edi,%ebx
   1104a:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
   11050:	50                   	push   %eax
   11051:	50                   	push   %eax
   11052:	53                   	push   %ebx
   11053:	8b 46 18             	mov    0x18(%esi),%eax
   11056:	83 c0 10             	add    $0x10,%eax
   11059:	50                   	push   %eax
   1105a:	ff 15 04 51 01 00    	call   *0x15104
   11060:	66 85 ff             	test   %di,%di
   11063:	59                   	pop    %ecx
   11064:	58                   	pop    %eax
   11065:	0f 88 e9 01 00 00    	js     11254 <_MiniportHandleInterrupt@4+0x254>
   1106b:	f6 c7 01             	test   $0x1,%bh
   1106e:	0f 85 f3 00 00 00    	jne    11167 <_MiniportHandleInterrupt@4+0x167>
   11074:	f6 c7 04             	test   $0x4,%bh
   11077:	0f 84 3f 01 00 00    	je     111bc <_MiniportHandleInterrupt@4+0x1bc>
   1107d:	8b 8e c8 00 00 00    	mov    0xc8(%esi),%ecx
   11083:	e9 c5 00 00 00       	jmp    1114d <_MiniportHandleInterrupt@4+0x14d>
   11088:	89 c2                	mov    %eax,%edx
   1108a:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   11090:	89 d0                	mov    %edx,%eax
   11092:	c1 e8 0e             	shr    $0xe,%eax
   11095:	83 e0 01             	and    $0x1,%eax
   11098:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   1109b:	0f 85 60 02 00 00    	jne    11301 <_MiniportHandleInterrupt@4+0x301>
   110a1:	f6 c6 02             	test   $0x2,%dh
   110a4:	0f 84 bd 00 00 00    	je     11167 <_MiniportHandleInterrupt@4+0x167>
   110aa:	80 e6 01             	and    $0x1,%dh
   110ad:	0f 84 b4 00 00 00    	je     11167 <_MiniportHandleInterrupt@4+0x167>
   110b3:	8d 14 49             	lea    (%ecx,%ecx,2),%edx
   110b6:	8b 86 10 01 00 00    	mov    0x110(%esi),%eax
   110bc:	c1 e2 09             	shl    $0x9,%edx
   110bf:	8b 4e 08             	mov    0x8(%esi),%ecx
   110c2:	01 c2                	add    %eax,%edx
   110c4:	66 8b 43 08          	mov    0x8(%ebx),%ax
   110c8:	25 ff 0f 00 00       	and    $0xfff,%eax
   110cd:	83 e8 0e             	sub    $0xe,%eax
   110d0:	50                   	push   %eax
   110d1:	50                   	push   %eax
   110d2:	8d 42 0e             	lea    0xe(%edx),%eax
   110d5:	50                   	push   %eax
   110d6:	6a 0e                	push   $0xe
   110d8:	52                   	push   %edx
   110d9:	52                   	push   %edx
   110da:	6a 00                	push   $0x0
   110dc:	8b b9 d8 00 00 00    	mov    0xd8(%ecx),%edi
   110e2:	57                   	push   %edi
   110e3:	ff 91 64 01 00 00    	call   *0x164(%ecx)
   110e9:	8b 46 08             	mov    0x8(%esi),%eax
   110ec:	83 ec 0c             	sub    $0xc,%esp
   110ef:	89 df                	mov    %ebx,%edi
   110f1:	8b 88 d8 00 00 00    	mov    0xd8(%eax),%ecx
   110f7:	51                   	push   %ecx
   110f8:	ff 90 70 01 00 00    	call   *0x170(%eax)
   110fe:	fc                   	cld    
   110ff:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11102:	b9 04 00 00 00       	mov    $0x4,%ecx
   11107:	f3 ab                	repz stos %eax,%es:(%edi)
   11109:	8b 86 c8 00 00 00    	mov    0xc8(%esi),%eax
   1110f:	8b 96 14 01 00 00    	mov    0x114(%esi),%edx
   11115:	66 81 4b 06 00 80    	orw    $0x8000,0x6(%ebx)
   1111b:	8d 04 40             	lea    (%eax,%eax,2),%eax
   1111e:	66 c7 43 04 00 fa    	movw   $0xfa00,0x4(%ebx)
   11124:	c1 e0 09             	shl    $0x9,%eax
   11127:	83 c4 0c             	add    $0xc,%esp
   1112a:	01 d0                	add    %edx,%eax
   1112c:	89 03                	mov    %eax,(%ebx)
   1112e:	8b 86 c8 00 00 00    	mov    0xc8(%esi),%eax
   11134:	40                   	inc    %eax
   11135:	83 e0 1f             	and    $0x1f,%eax
   11138:	89 c1                	mov    %eax,%ecx
   1113a:	89 86 c8 00 00 00    	mov    %eax,0xc8(%esi)
   11140:	8b 86 40 01 00 00    	mov    0x140(%esi),%eax
   11146:	40                   	inc    %eax
   11147:	89 86 40 01 00 00    	mov    %eax,0x140(%esi)
   1114d:	89 cb                	mov    %ecx,%ebx
   1114f:	8b 86 04 01 00 00    	mov    0x104(%esi),%eax
   11155:	c1 e3 04             	shl    $0x4,%ebx
   11158:	01 c3                	add    %eax,%ebx
   1115a:	66 8b 43 06          	mov    0x6(%ebx),%ax
   1115e:	66 85 c0             	test   %ax,%ax
   11161:	0f 89 21 ff ff ff    	jns    11088 <_MiniportHandleInterrupt@4+0x88>
   11167:	83 ec 0c             	sub    $0xc,%esp
   1116a:	8b 46 18             	mov    0x18(%esi),%eax
   1116d:	83 c0 10             	add    $0x10,%eax
   11170:	50                   	push   %eax
   11171:	ff 15 00 51 01 00    	call   *0x15100
   11177:	89 c7                	mov    %eax,%edi
   11179:	83 c4 0c             	add    $0xc,%esp
   1117c:	f7 c7 80 00 00 00    	test   $0x80,%edi
   11182:	0f 85 c0 fe ff ff    	jne    11048 <_MiniportHandleInterrupt@4+0x48>
    }

  /* re-enable interrupts */
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_IENA);
   11188:	52                   	push   %edx
   11189:	52                   	push   %edx
   1118a:	6a 40                	push   $0x40
   1118c:	8b 46 18             	mov    0x18(%esi),%eax
   1118f:	83 c0 10             	add    $0x10,%eax
   11192:	50                   	push   %eax
   11193:	ff 15 04 51 01 00    	call   *0x15104

  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
   11199:	50                   	push   %eax
   1119a:	8b 46 18             	mov    0x18(%esi),%eax
   1119d:	83 c0 10             	add    $0x10,%eax
   111a0:	50                   	push   %eax
   111a1:	ff 15 00 51 01 00    	call   *0x15100
  PCNET_DbgPrint(("CSR0 is now 0x%x\n", Data));

  NdisDprReleaseSpinLock(&Adapter->Lock);
   111a7:	89 f1                	mov    %esi,%ecx
   111a9:	83 c4 0c             	add    $0xc,%esp
   111ac:	ff 15 70 51 01 00    	call   *0x15170
   111b2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   111b5:	5b                   	pop    %ebx
   111b6:	5e                   	pop    %esi
   111b7:	5f                   	pop    %edi
   111b8:	5d                   	pop    %ebp
   111b9:	c2 04 00             	ret    $0x4
   111bc:	f6 c7 02             	test   $0x2,%bh
   111bf:	74 a6                	je     11167 <_MiniportHandleInterrupt@4+0x167>
   111c1:	8b 8e d4 00 00 00    	mov    0xd4(%esi),%ecx
   111c7:	8b be d8 00 00 00    	mov    0xd8(%esi),%edi
   111cd:	39 f9                	cmp    %edi,%ecx
   111cf:	0f 84 14 01 00 00    	je     112e9 <_MiniportHandleInterrupt@4+0x2e9>
   111d5:	8b 86 ec 00 00 00    	mov    0xec(%esi),%eax
   111db:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   111de:	eb 38                	jmp    11218 <_MiniportHandleInterrupt@4+0x218>
   111e0:	8b 86 38 01 00 00    	mov    0x138(%esi),%eax
   111e6:	40                   	inc    %eax
   111e7:	89 86 38 01 00 00    	mov    %eax,0x138(%esi)
   111ed:	8d 76 00             	lea    0x0(%esi),%esi
   111f0:	80 e6 40             	and    $0x40,%dh
   111f3:	75 7d                	jne    11272 <_MiniportHandleInterrupt@4+0x272>
   111f5:	8d 41 01             	lea    0x1(%ecx),%eax
   111f8:	8b 9e 18 01 00 00    	mov    0x118(%esi),%ebx
   111fe:	83 e0 1f             	and    $0x1f,%eax
   11201:	43                   	inc    %ebx
   11202:	89 c1                	mov    %eax,%ecx
   11204:	89 86 d4 00 00 00    	mov    %eax,0xd4(%esi)
   1120a:	89 9e 18 01 00 00    	mov    %ebx,0x118(%esi)
   11210:	39 f8                	cmp    %edi,%eax
   11212:	0f 84 d1 00 00 00    	je     112e9 <_MiniportHandleInterrupt@4+0x2e9>
   11218:	89 c8                	mov    %ecx,%eax
   1121a:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   1121d:	c1 e0 04             	shl    $0x4,%eax
   11220:	01 c3                	add    %eax,%ebx
   11222:	66 8b 53 06          	mov    0x6(%ebx),%dx
   11226:	66 85 d2             	test   %dx,%dx
   11229:	0f 88 ba 00 00 00    	js     112e9 <_MiniportHandleInterrupt@4+0x2e9>
   1122f:	89 d0                	mov    %edx,%eax
   11231:	25 ff ff 00 00       	and    $0xffff,%eax
   11236:	f6 c4 02             	test   $0x2,%ah
   11239:	74 b5                	je     111f0 <_MiniportHandleInterrupt@4+0x1f0>
   1123b:	f6 c4 08             	test   $0x8,%ah
   1123e:	75 a0                	jne    111e0 <_MiniportHandleInterrupt@4+0x1e0>
   11240:	f6 c4 10             	test   $0x10,%ah
   11243:	74 ab                	je     111f0 <_MiniportHandleInterrupt@4+0x1f0>
   11245:	8b 86 3c 01 00 00    	mov    0x13c(%esi),%eax
   1124b:	40                   	inc    %eax
   1124c:	89 86 3c 01 00 00    	mov    %eax,0x13c(%esi)
   11252:	eb 9c                	jmp    111f0 <_MiniportHandleInterrupt@4+0x1f0>
   11254:	80 e7 20             	and    $0x20,%bh
   11257:	0f 84 0a ff ff ff    	je     11167 <_MiniportHandleInterrupt@4+0x167>
   1125d:	8b 96 24 01 00 00    	mov    0x124(%esi),%edx
   11263:	83 ec 0c             	sub    $0xc,%esp
   11266:	42                   	inc    %edx
   11267:	89 96 24 01 00 00    	mov    %edx,0x124(%esi)
   1126d:	e9 f8 fe ff ff       	jmp    1116a <_MiniportHandleInterrupt@4+0x16a>
   11272:	66 8b 53 0a          	mov    0xa(%ebx),%dx
   11276:	89 d0                	mov    %edx,%eax
   11278:	25 ff ff 00 00       	and    $0xffff,%eax
   1127d:	f6 c4 04             	test   $0x4,%ah
   11280:	74 0d                	je     1128f <_MiniportHandleInterrupt@4+0x28f>
   11282:	8b 8e 1c 01 00 00    	mov    0x11c(%esi),%ecx
   11288:	41                   	inc    %ecx
   11289:	89 8e 1c 01 00 00    	mov    %ecx,0x11c(%esi)
   1128f:	f6 c4 08             	test   $0x8,%ah
   11292:	74 0d                	je     112a1 <_MiniportHandleInterrupt@4+0x2a1>
   11294:	8b be 20 01 00 00    	mov    0x120(%esi),%edi
   1129a:	47                   	inc    %edi
   1129b:	89 be 20 01 00 00    	mov    %edi,0x120(%esi)
   112a1:	f6 c4 10             	test   $0x10,%ah
   112a4:	74 0d                	je     112b3 <_MiniportHandleInterrupt@4+0x2b3>
   112a6:	8b 9e 28 01 00 00    	mov    0x128(%esi),%ebx
   112ac:	43                   	inc    %ebx
   112ad:	89 9e 28 01 00 00    	mov    %ebx,0x128(%esi)
   112b3:	f6 c4 20             	test   $0x20,%ah
   112b6:	74 0d                	je     112c5 <_MiniportHandleInterrupt@4+0x2c5>
   112b8:	8b 8e 2c 01 00 00    	mov    0x12c(%esi),%ecx
   112be:	41                   	inc    %ecx
   112bf:	89 8e 2c 01 00 00    	mov    %ecx,0x12c(%esi)
   112c5:	f6 c4 40             	test   $0x40,%ah
   112c8:	74 0d                	je     112d7 <_MiniportHandleInterrupt@4+0x2d7>
   112ca:	8b 86 30 01 00 00    	mov    0x130(%esi),%eax
   112d0:	40                   	inc    %eax
   112d1:	89 86 30 01 00 00    	mov    %eax,0x130(%esi)
   112d7:	66 85 d2             	test   %dx,%dx
   112da:	79 0d                	jns    112e9 <_MiniportHandleInterrupt@4+0x2e9>
   112dc:	8b be 34 01 00 00    	mov    0x134(%esi),%edi
   112e2:	47                   	inc    %edi
   112e3:	89 be 34 01 00 00    	mov    %edi,0x134(%esi)
   112e9:	83 ec 0c             	sub    $0xc,%esp
   112ec:	8b 46 08             	mov    0x8(%esi),%eax
   112ef:	50                   	push   %eax
   112f0:	ff 90 f0 00 00 00    	call   *0xf0(%eax)
   112f6:	83 c4 0c             	add    $0xc,%esp
   112f9:	83 ec 0c             	sub    $0xc,%esp
   112fc:	e9 69 fe ff ff       	jmp    1116a <_MiniportHandleInterrupt@4+0x16a>
   11301:	f6 c6 04             	test   $0x4,%dh
   11304:	74 0d                	je     11313 <_MiniportHandleInterrupt@4+0x313>
   11306:	8b 86 44 01 00 00    	mov    0x144(%esi),%eax
   1130c:	40                   	inc    %eax
   1130d:	89 86 44 01 00 00    	mov    %eax,0x144(%esi)
   11313:	f6 c6 08             	test   $0x8,%dh
   11316:	74 0d                	je     11325 <_MiniportHandleInterrupt@4+0x325>
   11318:	8b 86 48 01 00 00    	mov    0x148(%esi),%eax
   1131e:	40                   	inc    %eax
   1131f:	89 86 48 01 00 00    	mov    %eax,0x148(%esi)
   11325:	f6 c6 10             	test   $0x10,%dh
   11328:	74 0d                	je     11337 <_MiniportHandleInterrupt@4+0x337>
   1132a:	8b 86 4c 01 00 00    	mov    0x14c(%esi),%eax
   11330:	40                   	inc    %eax
   11331:	89 86 4c 01 00 00    	mov    %eax,0x14c(%esi)
   11337:	80 e6 20             	and    $0x20,%dh
   1133a:	0f 84 27 fe ff ff    	je     11167 <_MiniportHandleInterrupt@4+0x167>
   11340:	8b 86 50 01 00 00    	mov    0x150(%esi),%eax
   11346:	83 ec 0c             	sub    $0xc,%esp
   11349:	40                   	inc    %eax
   1134a:	89 86 50 01 00 00    	mov    %eax,0x150(%esi)
   11350:	e9 15 fe ff ff       	jmp    1116a <_MiniportHandleInterrupt@4+0x16a>
   11355:	8d 74 26 00          	lea    0x0(%esi),%esi
   11359:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011360 <_MiQueryCard>:
}

NDIS_STATUS 
MiQueryCard(
    IN PADAPTER Adapter)
/*
 * FUNCTION: Detect the PCNET NIC in the configured slot and query its I/O address and interrupt vector
 * ARGUMENTS:
 *     MiniportAdapterContext: context supplied to NdisMSetAttributes
 * RETURNS:
 *     NDIS_STATUS_FAILURE on a general error
 *     NDIS_STATUS_ADAPTER_NOT_FOUND on not finding the adapter
 *     NDIS_STATUS_SUCCESS on succes
 */
{
   11360:	55                   	push   %ebp
   11361:	89 e5                	mov    %esp,%ebp
   11363:	56                   	push   %esi
   11364:	53                   	push   %ebx
   11365:	83 ec 1c             	sub    $0x1c,%esp
  ULONG  buf32 = 0;
  UCHAR  buf8  = 0;
  NDIS_STATUS Status;

  /* Detect the card in the configured slot */
  Status = NdisReadPciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_PCIID, &buf32, 4);
   11368:	8d 5d f4             	lea    0xfffffff4(%ebp),%ebx
   1136b:	8b 75 08             	mov    0x8(%ebp),%esi
   1136e:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   11372:	6a 04                	push   $0x4
   11374:	53                   	push   %ebx
   11375:	6a 00                	push   $0x0
   11377:	6a 00                	push   $0x0
   11379:	8b 4e 08             	mov    0x8(%esi),%ecx
   1137c:	c7 45 f4 00 00 00 00 	movl   $0x0,0xfffffff4(%ebp)
   11383:	51                   	push   %ecx
   11384:	ff 15 58 51 01 00    	call   *0x15158
  if(Status != 4)
    {
      Status =  NDIS_STATUS_FAILURE;
      PCNET_DbgPrint(("NdisReadPciSlotInformation failed\n"));
      BREAKPOINT;
      return Status;
   1138a:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   1138f:	83 c4 0c             	add    $0xc,%esp
   11392:	83 f8 04             	cmp    $0x4,%eax
   11395:	74 09                	je     113a0 <_MiQueryCard+0x40>
    }

  if(buf32 != PCI_ID)
    {
      Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
      PCNET_DbgPrint(("card in slot isn't our: 0x%x\n", 0, buf32));
      BREAKPOINT;
      return Status;
    }

  /* set busmaster and io space enable bits */
  buf32 = PCI_BMEN | PCI_IOEN;
  NdisWritePciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_COMMAND, &buf32, 4);        

  /* get IO base physical address */
  buf32 = 0;
  Status = NdisReadPciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_IOBAR, &buf32, 4);
  if(Status != 4)
    {
      Status = NDIS_STATUS_FAILURE;
      PCNET_DbgPrint(("NdisReadPciSlotInformation failed\n"));
      BREAKPOINT;
      return Status;
    }

  if(!buf32)
    {
      PCNET_DbgPrint(("No base i/o address set\n"));
      return NDIS_STATUS_FAILURE;
    }

  buf32 &= ~1;  /* even up address - comes out odd for some reason */

  PCNET_DbgPrint(("detected io address 0x%x\n", buf32));
  Adapter->IoBaseAddress = buf32;

  /* get interrupt vector */
  Status = NdisReadPciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_ILR, &buf8, 1);
  if(Status != 1)
    {
      Status = NDIS_STATUS_FAILURE;
      PCNET_DbgPrint(("NdisReadPciSlotInformation failed\n"));
      BREAKPOINT;
      return Status;
    }

  PCNET_DbgPrint(("interrupt: 0x%x\n", buf8));
  Adapter->InterruptVector = buf8;

  return NDIS_STATUS_SUCCESS;
}
   11397:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1139a:	89 d0                	mov    %edx,%eax
   1139c:	5b                   	pop    %ebx
   1139d:	5e                   	pop    %esi
   1139e:	5d                   	pop    %ebp
   1139f:	c3                   	ret    
   113a0:	ba 06 00 01 c0       	mov    $0xc0010006,%edx
   113a5:	81 7d f4 22 10 00 20 	cmpl   $0x20001022,0xfffffff4(%ebp)
   113ac:	75 e9                	jne    11397 <_MiQueryCard+0x37>
   113ae:	83 ec 0c             	sub    $0xc,%esp
   113b1:	c7 45 f4 05 00 00 00 	movl   $0x5,0xfffffff4(%ebp)
   113b8:	6a 04                	push   $0x4
   113ba:	53                   	push   %ebx
   113bb:	6a 04                	push   $0x4
   113bd:	6a 00                	push   $0x0
   113bf:	8b 56 08             	mov    0x8(%esi),%edx
   113c2:	52                   	push   %edx
   113c3:	ff 15 60 51 01 00    	call   *0x15160
   113c9:	c7 45 f4 00 00 00 00 	movl   $0x0,0xfffffff4(%ebp)
   113d0:	6a 04                	push   $0x4
   113d2:	53                   	push   %ebx
   113d3:	6a 10                	push   $0x10
   113d5:	6a 00                	push   $0x0
   113d7:	8b 46 08             	mov    0x8(%esi),%eax
   113da:	50                   	push   %eax
   113db:	ff 15 58 51 01 00    	call   *0x15158
   113e1:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   113e6:	83 c4 0c             	add    $0xc,%esp
   113e9:	83 f8 04             	cmp    $0x4,%eax
   113ec:	75 a9                	jne    11397 <_MiQueryCard+0x37>
   113ee:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
   113f1:	85 c0                	test   %eax,%eax
   113f3:	74 a2                	je     11397 <_MiQueryCard+0x37>
   113f5:	83 ec 0c             	sub    $0xc,%esp
   113f8:	83 e0 fe             	and    $0xfffffffe,%eax
   113fb:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
   113fe:	89 46 14             	mov    %eax,0x14(%esi)
   11401:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11404:	6a 01                	push   $0x1
   11406:	50                   	push   %eax
   11407:	6a 3c                	push   $0x3c
   11409:	6a 00                	push   $0x0
   1140b:	8b 46 08             	mov    0x8(%esi),%eax
   1140e:	50                   	push   %eax
   1140f:	ff 15 58 51 01 00    	call   *0x15158
   11415:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   1141a:	83 c4 0c             	add    $0xc,%esp
   1141d:	48                   	dec    %eax
   1141e:	0f 85 73 ff ff ff    	jne    11397 <_MiQueryCard+0x37>
   11424:	31 c0                	xor    %eax,%eax
   11426:	31 d2                	xor    %edx,%edx
   11428:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1142b:	89 46 10             	mov    %eax,0x10(%esi)
   1142e:	e9 64 ff ff ff       	jmp    11397 <_MiQueryCard+0x37>
   11433:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11439:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011440 <_MiAllocateSharedMemory>:

NDIS_STATUS
MiAllocateSharedMemory(
    PADAPTER Adapter)
/*
 * FUNCTION: Allocate all shared memory used by the miniport
 * ARGUMENTS:
 *     Adapter: Pointer to the miniport's adapter object
 * RETURNS:
 *     NDIS_STATUS_RESOURCES on insufficient memory
 *     NDIS_STATUS_SUCCESS on success
 */
{
   11440:	55                   	push   %ebp
   11441:	89 e5                	mov    %esp,%ebp
   11443:	56                   	push   %esi
   11444:	53                   	push   %ebx
   11445:	83 ec 1c             	sub    $0x1c,%esp
  PTRANSMIT_DESCRIPTOR TransmitDescriptor;
  PRECEIVE_DESCRIPTOR  ReceiveDescriptor;
  NDIS_PHYSICAL_ADDRESS PhysicalAddress;
  ULONG i;

  /* allocate the initialization block */
  Adapter->InitializationBlockLength = sizeof(INITIALIZATION_BLOCK);
  NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->InitializationBlockLength, 
   11448:	8d 5d f0             	lea    0xfffffff0(%ebp),%ebx
   1144b:	8b 75 08             	mov    0x8(%ebp),%esi
   1144e:	8d 86 e0 00 00 00    	lea    0xe0(%esi),%eax
   11454:	c7 86 dc 00 00 00 1c 	movl   $0x1c,0xdc(%esi)
   1145b:	00 00 00 
   1145e:	53                   	push   %ebx
   1145f:	50                   	push   %eax
   11460:	6a 00                	push   $0x0
   11462:	6a 1c                	push   $0x1c
   11464:	8b 4e 08             	mov    0x8(%esi),%ecx
   11467:	51                   	push   %ecx
   11468:	ff 15 24 51 01 00    	call   *0x15124
      FALSE, (PVOID *)&Adapter->InitializationBlockVirt, &PhysicalAddress);
  if(!Adapter->InitializationBlockVirt)
   1146e:	8b 96 e0 00 00 00    	mov    0xe0(%esi),%edx
   11474:	83 c4 0c             	add    $0xc,%esp
    {
      PCNET_DbgPrint(("insufficient resources\n"));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
   11477:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   1147c:	85 d2                	test   %edx,%edx
   1147e:	0f 84 e4 01 00 00    	je     11668 <_MiAllocateSharedMemory+0x228>
    }

  if(((ULONG)Adapter->InitializationBlockVirt & 0x00000003) != 0)
   11484:	83 e2 03             	and    $0x3,%edx
   11487:	0f 85 db 01 00 00    	jne    11668 <_MiAllocateSharedMemory+0x228>
    {
      PCNET_DbgPrint(("address 0x%x not dword-aligned\n", Adapter->InitializationBlockVirt));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
    }

  Adapter->InitializationBlockPhys = (PINITIALIZATION_BLOCK)NdisGetPhysicalAddressLow(PhysicalAddress);

  /* allocate the transport descriptor ring */
  Adapter->TransmitDescriptorRingLength = sizeof(TRANSMIT_DESCRIPTOR) * NUMBER_OF_BUFFERS;
  NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitDescriptorRingLength,
   1148d:	83 ec 0c             	sub    $0xc,%esp
   11490:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11493:	89 86 e4 00 00 00    	mov    %eax,0xe4(%esi)
   11499:	8d 86 ec 00 00 00    	lea    0xec(%esi),%eax
   1149f:	c7 86 e8 00 00 00 00 	movl   $0x200,0xe8(%esi)
   114a6:	02 00 00 
   114a9:	53                   	push   %ebx
   114aa:	50                   	push   %eax
   114ab:	6a 00                	push   $0x0
   114ad:	68 00 02 00 00       	push   $0x200
   114b2:	8b 56 08             	mov    0x8(%esi),%edx
   114b5:	52                   	push   %edx
   114b6:	ff 15 24 51 01 00    	call   *0x15124
      FALSE, (PVOID *)&Adapter->TransmitDescriptorRingVirt, &PhysicalAddress);
  if(!Adapter->TransmitDescriptorRingVirt)
   114bc:	8b 96 ec 00 00 00    	mov    0xec(%esi),%edx
   114c2:	83 c4 0c             	add    $0xc,%esp
    {
      PCNET_DbgPrint(("insufficient resources\n"));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
   114c5:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   114ca:	85 d2                	test   %edx,%edx
   114cc:	0f 84 96 01 00 00    	je     11668 <_MiAllocateSharedMemory+0x228>
    }

  if(((ULONG)Adapter->TransmitDescriptorRingVirt & 0x00000003) != 0)
   114d2:	f6 c2 03             	test   $0x3,%dl
   114d5:	0f 85 8d 01 00 00    	jne    11668 <_MiAllocateSharedMemory+0x228>
    {
      PCNET_DbgPrint(("address 0x%x not dword-aligned\n", Adapter->TransmitDescriptorRingVirt));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
    }

  Adapter->TransmitDescriptorRingPhys = (PTRANSMIT_DESCRIPTOR)NdisGetPhysicalAddressLow(PhysicalAddress);
   114db:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   114de:	89 86 f0 00 00 00    	mov    %eax,0xf0(%esi)
  RtlZeroMemory(Adapter->TransmitDescriptorRingVirt, sizeof(TRANSMIT_DESCRIPTOR) * NUMBER_OF_BUFFERS);
   114e4:	50                   	push   %eax
   114e5:	68 00 02 00 00       	push   $0x200
   114ea:	6a 00                	push   $0x0
   114ec:	52                   	push   %edx
   114ed:	e8 3e 15 00 00       	call   12a30 <_memset>

  /* allocate the receive descriptor ring */
  Adapter->ReceiveDescriptorRingLength = sizeof(RECEIVE_DESCRIPTOR) * NUMBER_OF_BUFFERS;
  NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveDescriptorRingLength,
   114f2:	8d 86 04 01 00 00    	lea    0x104(%esi),%eax
   114f8:	c7 86 00 01 00 00 00 	movl   $0x200,0x100(%esi)
   114ff:	02 00 00 
   11502:	89 1c 24             	mov    %ebx,(%esp)
   11505:	50                   	push   %eax
   11506:	6a 00                	push   $0x0
   11508:	68 00 02 00 00       	push   $0x200
   1150d:	8b 46 08             	mov    0x8(%esi),%eax
   11510:	50                   	push   %eax
   11511:	ff 15 24 51 01 00    	call   *0x15124
      FALSE, (PVOID *)&Adapter->ReceiveDescriptorRingVirt, &PhysicalAddress);
  if(!Adapter->ReceiveDescriptorRingVirt)
   11517:	8b 96 04 01 00 00    	mov    0x104(%esi),%edx
   1151d:	83 c4 0c             	add    $0xc,%esp
    {
      PCNET_DbgPrint(("insufficient resources\n"));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
   11520:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   11525:	85 d2                	test   %edx,%edx
   11527:	0f 84 3b 01 00 00    	je     11668 <_MiAllocateSharedMemory+0x228>
    }

  if(((ULONG)Adapter->ReceiveDescriptorRingVirt & 0x00000003) != 0)
   1152d:	f6 c2 03             	test   $0x3,%dl
   11530:	0f 85 32 01 00 00    	jne    11668 <_MiAllocateSharedMemory+0x228>
    {
      PCNET_DbgPrint(("address 0x%x not dword-aligned\n", Adapter->ReceiveDescriptorRingVirt));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
    }

  Adapter->ReceiveDescriptorRingPhys = (PRECEIVE_DESCRIPTOR)NdisGetPhysicalAddressLow(PhysicalAddress);
   11536:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11539:	89 86 08 01 00 00    	mov    %eax,0x108(%esi)
  RtlZeroMemory(Adapter->ReceiveDescriptorRingVirt, sizeof(RECEIVE_DESCRIPTOR) * NUMBER_OF_BUFFERS);
   1153f:	50                   	push   %eax
   11540:	68 00 02 00 00       	push   $0x200
   11545:	6a 00                	push   $0x0
   11547:	52                   	push   %edx
   11548:	e8 e3 14 00 00       	call   12a30 <_memset>

  /* allocate transmit buffers */
  Adapter->TransmitBufferLength = BUFFER_SIZE * NUMBER_OF_BUFFERS;
  NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitBufferLength, 
   1154d:	8d 86 f8 00 00 00    	lea    0xf8(%esi),%eax
   11553:	c7 86 f4 00 00 00 00 	movl   $0xc000,0xf4(%esi)
   1155a:	c0 00 00 
   1155d:	89 1c 24             	mov    %ebx,(%esp)
   11560:	50                   	push   %eax
   11561:	6a 00                	push   $0x0
   11563:	68 00 c0 00 00       	push   $0xc000
   11568:	8b 46 08             	mov    0x8(%esi),%eax
   1156b:	50                   	push   %eax
   1156c:	ff 15 24 51 01 00    	call   *0x15124
      FALSE, (PVOID *)&Adapter->TransmitBufferPtrVirt, &PhysicalAddress);
  if(!Adapter->TransmitBufferPtrVirt)
   11572:	8b 96 f8 00 00 00    	mov    0xf8(%esi),%edx
   11578:	83 c4 0c             	add    $0xc,%esp
    {
      PCNET_DbgPrint(("insufficient resources\n"));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
   1157b:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   11580:	85 d2                	test   %edx,%edx
   11582:	0f 84 e0 00 00 00    	je     11668 <_MiAllocateSharedMemory+0x228>
    }

  if(((ULONG)Adapter->TransmitBufferPtrVirt & 0x00000003) != 0)
   11588:	f6 c2 03             	test   $0x3,%dl
   1158b:	0f 85 d7 00 00 00    	jne    11668 <_MiAllocateSharedMemory+0x228>
    {
      PCNET_DbgPrint(("address 0x%x not dword-aligned\n", Adapter->TransmitBufferPtrVirt));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
    }

  Adapter->TransmitBufferPtrPhys = (PCHAR)NdisGetPhysicalAddressLow(PhysicalAddress);
   11591:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11594:	89 86 fc 00 00 00    	mov    %eax,0xfc(%esi)
  RtlZeroMemory(Adapter->TransmitBufferPtrVirt, BUFFER_SIZE * NUMBER_OF_BUFFERS);
   1159a:	50                   	push   %eax
   1159b:	68 00 c0 00 00       	push   $0xc000
   115a0:	6a 00                	push   $0x0
   115a2:	52                   	push   %edx
   115a3:	e8 88 14 00 00       	call   12a30 <_memset>

  /* allocate receive buffers */
  Adapter->ReceiveBufferLength = BUFFER_SIZE * NUMBER_OF_BUFFERS;
  NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveBufferLength, 
   115a8:	8d 86 10 01 00 00    	lea    0x110(%esi),%eax
   115ae:	c7 86 0c 01 00 00 00 	movl   $0xc000,0x10c(%esi)
   115b5:	c0 00 00 
   115b8:	89 1c 24             	mov    %ebx,(%esp)
   115bb:	50                   	push   %eax
   115bc:	6a 00                	push   $0x0
   115be:	68 00 c0 00 00       	push   $0xc000
   115c3:	8b 46 08             	mov    0x8(%esi),%eax
   115c6:	50                   	push   %eax
   115c7:	ff 15 24 51 01 00    	call   *0x15124
      FALSE, (PVOID *)&Adapter->ReceiveBufferPtrVirt, &PhysicalAddress);
  if(!Adapter->ReceiveBufferPtrVirt)
   115cd:	8b 96 10 01 00 00    	mov    0x110(%esi),%edx
   115d3:	83 c4 0c             	add    $0xc,%esp
    {
      PCNET_DbgPrint(("insufficient resources\n"));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
   115d6:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   115db:	85 d2                	test   %edx,%edx
   115dd:	0f 84 85 00 00 00    	je     11668 <_MiAllocateSharedMemory+0x228>
    }

  if(((ULONG)Adapter->ReceiveBufferPtrVirt & 0x00000003) != 0)
   115e3:	f6 c2 03             	test   $0x3,%dl
   115e6:	0f 85 7c 00 00 00    	jne    11668 <_MiAllocateSharedMemory+0x228>
    {
      PCNET_DbgPrint(("address 0x%x not dword-aligned\n", Adapter->ReceiveBufferPtrVirt));
      BREAKPOINT;
      return NDIS_STATUS_RESOURCES;
    }

  Adapter->ReceiveBufferPtrPhys = (PCHAR)NdisGetPhysicalAddressLow(PhysicalAddress);
   115ec:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   115ef:	89 86 14 01 00 00    	mov    %eax,0x114(%esi)
  RtlZeroMemory(Adapter->ReceiveBufferPtrVirt, BUFFER_SIZE * NUMBER_OF_BUFFERS);
   115f5:	53                   	push   %ebx
   115f6:	68 00 c0 00 00       	push   $0xc000
   115fb:	6a 00                	push   $0x0
   115fd:	52                   	push   %edx

  /* initialize tx descriptors */
  TransmitDescriptor = Adapter->TransmitDescriptorRingVirt;
  for(i = 0; i < NUMBER_OF_BUFFERS; i++)
   115fe:	31 db                	xor    %ebx,%ebx
   11600:	e8 2b 14 00 00       	call   12a30 <_memset>
   11605:	8b 8e ec 00 00 00    	mov    0xec(%esi),%ecx
   1160b:	83 c4 10             	add    $0x10,%esp
   1160e:	8b 96 fc 00 00 00    	mov    0xfc(%esi),%edx
    {
      (TransmitDescriptor+i)->TBADR = (ULONG)Adapter->TransmitBufferPtrPhys + i * BUFFER_SIZE;
   11614:	89 d8                	mov    %ebx,%eax
   11616:	43                   	inc    %ebx
   11617:	c1 e0 04             	shl    $0x4,%eax
   1161a:	89 14 08             	mov    %edx,(%eax,%ecx,1)
      (TransmitDescriptor+i)->BCNT = 0xf000 | -BUFFER_SIZE; /* 2's compliment  + set top 4 bits */
   1161d:	66 c7 44 08 04 00 fa 	movw   $0xfa00,0x4(%eax,%ecx,1)
   11624:	81 c2 00 06 00 00    	add    $0x600,%edx
      (TransmitDescriptor+i)->FLAGS = TD1_STP | TD1_ENP;
   1162a:	66 c7 44 08 06 00 03 	movw   $0x300,0x6(%eax,%ecx,1)
   11631:	83 fb 1f             	cmp    $0x1f,%ebx
   11634:	76 de                	jbe    11614 <_MiAllocateSharedMemory+0x1d4>
    }

  PCNET_DbgPrint(("transmit ring initialized\n"));

  /* initialize rx */
  ReceiveDescriptor = Adapter->ReceiveDescriptorRingVirt;
   11636:	8b 8e 04 01 00 00    	mov    0x104(%esi),%ecx
  for(i = 0; i < NUMBER_OF_BUFFERS; i++)
   1163c:	31 db                	xor    %ebx,%ebx
   1163e:	8b 96 14 01 00 00    	mov    0x114(%esi),%edx
    {
      (ReceiveDescriptor+i)->RBADR = (ULONG)Adapter->ReceiveBufferPtrPhys + i * BUFFER_SIZE;
   11644:	89 d8                	mov    %ebx,%eax
   11646:	43                   	inc    %ebx
   11647:	c1 e0 04             	shl    $0x4,%eax
   1164a:	89 14 08             	mov    %edx,(%eax,%ecx,1)
      (ReceiveDescriptor+i)->BCNT = 0xf000 | -BUFFER_SIZE; /* 2's compliment  + set top 4 bits */
   1164d:	66 c7 44 08 04 00 fa 	movw   $0xfa00,0x4(%eax,%ecx,1)
   11654:	81 c2 00 06 00 00    	add    $0x600,%edx
      (ReceiveDescriptor+i)->FLAGS = RD_OWN;
   1165a:	66 c7 44 08 06 00 80 	movw   $0x8000,0x6(%eax,%ecx,1)
   11661:	83 fb 1f             	cmp    $0x1f,%ebx
   11664:	76 de                	jbe    11644 <_MiAllocateSharedMemory+0x204>
    }

  PCNET_DbgPrint(("receive ring initialized\n"));

  return NDIS_STATUS_SUCCESS;
   11666:	31 c0                	xor    %eax,%eax
}
   11668:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1166b:	5b                   	pop    %ebx
   1166c:	5e                   	pop    %esi
   1166d:	5d                   	pop    %ebp
   1166e:	c3                   	ret    
   1166f:	90                   	nop    

00011670 <_MiPrepareInitializationBlock>:

VOID
MiPrepareInitializationBlock(
    PADAPTER Adapter)
/*
 * FUNCTION: Initialize the initialization block
 * ARGUMENTS:
 *     Adapter: pointer to the miniport's adapter object
 */
{
   11670:	55                   	push   %ebp
  ULONG i = 0;

  RtlZeroMemory(Adapter->InitializationBlockVirt, sizeof(INITIALIZATION_BLOCK));
   11671:	b9 07 00 00 00       	mov    $0x7,%ecx
   11676:	89 e5                	mov    %esp,%ebp
   11678:	57                   	push   %edi
   11679:	56                   	push   %esi
   1167a:	53                   	push   %ebx
   1167b:	83 ec 0c             	sub    $0xc,%esp
   1167e:	31 db                	xor    %ebx,%ebx
   11680:	8b 75 08             	mov    0x8(%ebp),%esi
   11683:	89 d8                	mov    %ebx,%eax
   11685:	fc                   	cld    
   11686:	8b be e0 00 00 00    	mov    0xe0(%esi),%edi
   1168c:	f3 ab                	repz stos %eax,%es:(%edi)
   1168e:	89 f6                	mov    %esi,%esi

  /* read burned-in address from card */
  for(i = 0; i < 6; i++)
    NdisRawReadPortUchar(Adapter->PortOffset + i, Adapter->InitializationBlockVirt->PADR + i);
   11690:	83 ec 0c             	sub    $0xc,%esp
   11693:	8b 46 18             	mov    0x18(%esi),%eax
   11696:	01 d8                	add    %ebx,%eax
   11698:	50                   	push   %eax
   11699:	ff 15 fc 50 01 00    	call   *0x150fc
   1169f:	8b 96 e0 00 00 00    	mov    0xe0(%esi),%edx
   116a5:	83 c4 0c             	add    $0xc,%esp
   116a8:	88 44 1a 04          	mov    %al,0x4(%edx,%ebx,1)
   116ac:	43                   	inc    %ebx
   116ad:	83 fb 05             	cmp    $0x5,%ebx
   116b0:	76 de                	jbe    11690 <_MiPrepareInitializationBlock+0x20>
  PCNET_DbgPrint(("MAC address: %02x-%02x-%02x-%02x-%02x-%02x\n",
                  Adapter->InitializationBlockVirt->PADR[0],
                  Adapter->InitializationBlockVirt->PADR[1],
                  Adapter->InitializationBlockVirt->PADR[2],
                  Adapter->InitializationBlockVirt->PADR[3],
                  Adapter->InitializationBlockVirt->PADR[4],
                  Adapter->InitializationBlockVirt->PADR[5]));

  /* set up receive ring */
  PCNET_DbgPrint(("Receive ring physical address: 0x%x\n", Adapter->ReceiveDescriptorRingPhys));
  Adapter->InitializationBlockVirt->RDRA = (ULONG)Adapter->ReceiveDescriptorRingPhys;
   116b2:	8b 96 e0 00 00 00    	mov    0xe0(%esi),%edx
   116b8:	8b 86 08 01 00 00    	mov    0x108(%esi),%eax
  Adapter->InitializationBlockVirt->RLEN = (LOG_NUMBER_OF_BUFFERS << 4) & 0xf0;
   116be:	c6 42 02 50          	movb   $0x50,0x2(%edx)
   116c2:	89 42 14             	mov    %eax,0x14(%edx)

  /* set up transmit ring */
  PCNET_DbgPrint(("Transmit ring physical address: 0x%x\n", Adapter->TransmitDescriptorRingPhys));
  Adapter->InitializationBlockVirt->TDRA = (ULONG)Adapter->TransmitDescriptorRingPhys;
   116c5:	8b 96 e0 00 00 00    	mov    0xe0(%esi),%edx
   116cb:	8b 86 f0 00 00 00    	mov    0xf0(%esi),%eax
   116d1:	89 42 18             	mov    %eax,0x18(%edx)
  Adapter->InitializationBlockVirt->TLEN = (LOG_NUMBER_OF_BUFFERS << 4) & 0xf0;
   116d4:	c6 42 03 50          	movb   $0x50,0x3(%edx)
   116d8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   116db:	5b                   	pop    %ebx
   116dc:	5e                   	pop    %esi
   116dd:	5f                   	pop    %edi
   116de:	5d                   	pop    %ebp
   116df:	c3                   	ret    

000116e0 <_MiFreeSharedMemory>:
}

VOID
MiFreeSharedMemory(
    PADAPTER Adapter)
/*
 * FUNCTION: Free all allocated shared memory
 * ARGUMENTS:
 *     Adapter: pointer to the miniport's adapter struct
 */
{
   116e0:	55                   	push   %ebp
   116e1:	89 e5                	mov    %esp,%ebp
   116e3:	57                   	push   %edi
   116e4:	56                   	push   %esi
   116e5:	53                   	push   %ebx
   116e6:	83 ec 0c             	sub    $0xc,%esp
  NDIS_PHYSICAL_ADDRESS PhysicalAddress;

  PhysicalAddress.u.HighPart = 0;
   116e9:	31 f6                	xor    %esi,%esi
   116eb:	8b 7d 08             	mov    0x8(%ebp),%edi

  if(Adapter->InitializationBlockVirt)
   116ee:	8b 87 e0 00 00 00    	mov    0xe0(%edi),%eax
   116f4:	85 c0                	test   %eax,%eax
   116f6:	75 3c                	jne    11734 <_MiFreeSharedMemory+0x54>
    {
      PhysicalAddress.u.LowPart = (ULONG)Adapter->InitializationBlockPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->InitializationBlockLength, 
          FALSE, Adapter->InitializationBlockVirt, PhysicalAddress);
    }

  if(Adapter->TransmitDescriptorRingVirt)
   116f8:	8b 87 ec 00 00 00    	mov    0xec(%edi),%eax
   116fe:	85 c0                	test   %eax,%eax
   11700:	75 5e                	jne    11760 <_MiFreeSharedMemory+0x80>
    {
      PhysicalAddress.u.LowPart = (ULONG)Adapter->TransmitDescriptorRingPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitDescriptorRingLength,
        FALSE, Adapter->TransmitDescriptorRingVirt, PhysicalAddress);
    }

  if(Adapter->ReceiveDescriptorRingVirt)
   11702:	8b 87 04 01 00 00    	mov    0x104(%edi),%eax
   11708:	85 c0                	test   %eax,%eax
   1170a:	0f 85 80 00 00 00    	jne    11790 <_MiFreeSharedMemory+0xb0>
    {
      PhysicalAddress.u.LowPart = (ULONG)Adapter->ReceiveDescriptorRingPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveDescriptorRingLength,
          FALSE, Adapter->ReceiveDescriptorRingVirt, PhysicalAddress);
    }

  if(Adapter->TransmitBufferPtrVirt)
   11710:	8b 87 f8 00 00 00    	mov    0xf8(%edi),%eax
   11716:	85 c0                	test   %eax,%eax
   11718:	0f 85 a2 00 00 00    	jne    117c0 <_MiFreeSharedMemory+0xe0>
    {
      PhysicalAddress.u.LowPart = (ULONG)Adapter->TransmitBufferPtrPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitBufferLength, 
          FALSE, Adapter->TransmitBufferPtrVirt, PhysicalAddress);
    }

  if(Adapter->ReceiveBufferPtrVirt)
   1171e:	8b 87 10 01 00 00    	mov    0x110(%edi),%eax
   11724:	85 c0                	test   %eax,%eax
   11726:	0f 85 c4 00 00 00    	jne    117f0 <_MiFreeSharedMemory+0x110>
    {
      PhysicalAddress.u.LowPart = (ULONG)Adapter->ReceiveBufferPtrPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveBufferLength, 
          FALSE, Adapter->ReceiveBufferPtrVirt, PhysicalAddress);
    }
}
   1172c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1172f:	5b                   	pop    %ebx
   11730:	5e                   	pop    %esi
   11731:	5f                   	pop    %edi
   11732:	5d                   	pop    %ebp
   11733:	c3                   	ret    
   11734:	8b 9f e4 00 00 00    	mov    0xe4(%edi),%ebx
   1173a:	52                   	push   %edx
   1173b:	52                   	push   %edx
   1173c:	56                   	push   %esi
   1173d:	53                   	push   %ebx
   1173e:	50                   	push   %eax
   1173f:	6a 00                	push   $0x0
   11741:	8b 87 dc 00 00 00    	mov    0xdc(%edi),%eax
   11747:	50                   	push   %eax
   11748:	8b 47 08             	mov    0x8(%edi),%eax
   1174b:	50                   	push   %eax
   1174c:	ff 15 38 51 01 00    	call   *0x15138
   11752:	8b 87 ec 00 00 00    	mov    0xec(%edi),%eax
   11758:	59                   	pop    %ecx
   11759:	85 c0                	test   %eax,%eax
   1175b:	5b                   	pop    %ebx
   1175c:	74 a4                	je     11702 <_MiFreeSharedMemory+0x22>
   1175e:	89 f6                	mov    %esi,%esi
   11760:	8b 9f f0 00 00 00    	mov    0xf0(%edi),%ebx
   11766:	52                   	push   %edx
   11767:	52                   	push   %edx
   11768:	56                   	push   %esi
   11769:	53                   	push   %ebx
   1176a:	50                   	push   %eax
   1176b:	6a 00                	push   $0x0
   1176d:	8b 87 e8 00 00 00    	mov    0xe8(%edi),%eax
   11773:	50                   	push   %eax
   11774:	8b 47 08             	mov    0x8(%edi),%eax
   11777:	50                   	push   %eax
   11778:	ff 15 38 51 01 00    	call   *0x15138
   1177e:	8b 87 04 01 00 00    	mov    0x104(%edi),%eax
   11784:	59                   	pop    %ecx
   11785:	85 c0                	test   %eax,%eax
   11787:	5b                   	pop    %ebx
   11788:	74 86                	je     11710 <_MiFreeSharedMemory+0x30>
   1178a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11790:	8b 9f 08 01 00 00    	mov    0x108(%edi),%ebx
   11796:	52                   	push   %edx
   11797:	52                   	push   %edx
   11798:	56                   	push   %esi
   11799:	53                   	push   %ebx
   1179a:	50                   	push   %eax
   1179b:	6a 00                	push   $0x0
   1179d:	8b 87 00 01 00 00    	mov    0x100(%edi),%eax
   117a3:	50                   	push   %eax
   117a4:	8b 47 08             	mov    0x8(%edi),%eax
   117a7:	50                   	push   %eax
   117a8:	ff 15 38 51 01 00    	call   *0x15138
   117ae:	8b 87 f8 00 00 00    	mov    0xf8(%edi),%eax
   117b4:	59                   	pop    %ecx
   117b5:	85 c0                	test   %eax,%eax
   117b7:	5b                   	pop    %ebx
   117b8:	0f 84 60 ff ff ff    	je     1171e <_MiFreeSharedMemory+0x3e>
   117be:	89 f6                	mov    %esi,%esi
   117c0:	8b 9f fc 00 00 00    	mov    0xfc(%edi),%ebx
   117c6:	52                   	push   %edx
   117c7:	52                   	push   %edx
   117c8:	56                   	push   %esi
   117c9:	53                   	push   %ebx
   117ca:	50                   	push   %eax
   117cb:	6a 00                	push   $0x0
   117cd:	8b 87 f4 00 00 00    	mov    0xf4(%edi),%eax
   117d3:	50                   	push   %eax
   117d4:	8b 47 08             	mov    0x8(%edi),%eax
   117d7:	50                   	push   %eax
   117d8:	ff 15 38 51 01 00    	call   *0x15138
   117de:	8b 87 10 01 00 00    	mov    0x110(%edi),%eax
   117e4:	59                   	pop    %ecx
   117e5:	85 c0                	test   %eax,%eax
   117e7:	5b                   	pop    %ebx
   117e8:	0f 84 3e ff ff ff    	je     1172c <_MiFreeSharedMemory+0x4c>
   117ee:	89 f6                	mov    %esi,%esi
   117f0:	8b 9f 14 01 00 00    	mov    0x114(%edi),%ebx
   117f6:	52                   	push   %edx
   117f7:	52                   	push   %edx
   117f8:	56                   	push   %esi
   117f9:	53                   	push   %ebx
   117fa:	50                   	push   %eax
   117fb:	6a 00                	push   $0x0
   117fd:	8b 87 0c 01 00 00    	mov    0x10c(%edi),%eax
   11803:	50                   	push   %eax
   11804:	8b 7f 08             	mov    0x8(%edi),%edi
   11807:	57                   	push   %edi
   11808:	ff 15 38 51 01 00    	call   *0x15138
   1180e:	5b                   	pop    %ebx
   1180f:	5e                   	pop    %esi
   11810:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11813:	5b                   	pop    %ebx
   11814:	5e                   	pop    %esi
   11815:	5f                   	pop    %edi
   11816:	5d                   	pop    %ebp
   11817:	c3                   	ret    
   11818:	90                   	nop    
   11819:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011820 <_MiSyncStop@4>:

BOOLEAN
STDCALL
MiSyncStop(
    IN PVOID SynchronizeContext)
/*
 * FUNCTION: Stop the adapter
 * ARGUMENTS:
 *     SynchronizeContext: Adapter context
 */
{
   11820:	55                   	push   %ebp
   11821:	89 e5                	mov    %esp,%ebp
   11823:	53                   	push   %ebx
   11824:	83 ec 0c             	sub    $0xc,%esp
   11827:	8b 5d 08             	mov    0x8(%ebp),%ebx
  PADAPTER Adapter = (PADAPTER)SynchronizeContext;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
   1182a:	6a 00                	push   $0x0
   1182c:	8b 43 18             	mov    0x18(%ebx),%eax
   1182f:	83 c0 12             	add    $0x12,%eax
   11832:	50                   	push   %eax
   11833:	ff 15 04 51 01 00    	call   *0x15104
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STOP);
   11839:	6a 04                	push   $0x4
   1183b:	8b 43 18             	mov    0x18(%ebx),%eax
   1183e:	83 c0 10             	add    $0x10,%eax
   11841:	50                   	push   %eax
   11842:	ff 15 04 51 01 00    	call   *0x15104
  return TRUE;
}
   11848:	b8 01 00 00 00       	mov    $0x1,%eax
   1184d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11850:	c9                   	leave  
   11851:	c2 04 00             	ret    $0x4
   11854:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1185a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011860 <_MiniportHalt@4>:
    
VOID
STDCALL
MiniportHalt(
    IN NDIS_HANDLE MiniportAdapterContext)
/*
 * FUNCTION: Stop the adapter and release any per-adapter resources
 * ARGUMENTS:
 *     MiniportAdapterContext: context specified to NdisMSetAttributes
 * NOTES:
 *     - Called by NDIS at PASSIVE_LEVEL
 */
{
   11860:	55                   	push   %ebp
   11861:	89 e5                	mov    %esp,%ebp
   11863:	56                   	push   %esi
   11864:	53                   	push   %ebx
   11865:	83 ec 18             	sub    $0x18,%esp
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
  BOOLEAN TimerCancelled;

  PCNET_DbgPrint(("Called\n"));
  ASSERT(Adapter);

  /* stop the media detection timer */
  NdisMCancelTimer(&Adapter->MediaDetectionTimer, &TimerCancelled);
   11868:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
   1186b:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1186e:	50                   	push   %eax
   1186f:	8d 43 70             	lea    0x70(%ebx),%eax

  /* stop the chip */
  NdisMSynchronizeWithInterrupt(&Adapter->InterruptObject, MiSyncStop, Adapter);
   11872:	8d 73 1c             	lea    0x1c(%ebx),%esi
   11875:	50                   	push   %eax
   11876:	ff 15 28 51 01 00    	call   *0x15128
   1187c:	89 1c 24             	mov    %ebx,(%esp)
   1187f:	68 20 18 01 00       	push   $0x11820
   11884:	56                   	push   %esi
   11885:	ff 15 54 51 01 00    	call   *0x15154

  /* deregister the interrupt */
  NdisMDeregisterInterrupt(&Adapter->InterruptObject);
   1188b:	50                   	push   %eax
   1188c:	50                   	push   %eax
   1188d:	56                   	push   %esi
   1188e:	ff 15 2c 51 01 00    	call   *0x1512c

  /* deregister i/o port range */
  NdisMDeregisterIoPortRange(Adapter->MiniportAdapterHandle, Adapter->IoBaseAddress, NUMBER_OF_PORTS, Adapter->PortOffset);
   11894:	83 c4 0c             	add    $0xc,%esp
   11897:	8b 43 18             	mov    0x18(%ebx),%eax
   1189a:	50                   	push   %eax
   1189b:	6a 20                	push   $0x20
   1189d:	8b 43 14             	mov    0x14(%ebx),%eax
   118a0:	50                   	push   %eax
   118a1:	8b 43 08             	mov    0x8(%ebx),%eax
   118a4:	50                   	push   %eax
   118a5:	ff 15 30 51 01 00    	call   *0x15130

  /* free shared memory */
  MiFreeSharedMemory(Adapter);
   118ab:	83 ec 0c             	sub    $0xc,%esp
   118ae:	53                   	push   %ebx
   118af:	e8 2c fe ff ff       	call   116e0 <_MiFreeSharedMemory>

  /* free map registers */
  NdisMFreeMapRegisters(Adapter->MiniportAdapterHandle);
   118b4:	58                   	pop    %eax
   118b5:	8b 43 08             	mov    0x8(%ebx),%eax
   118b8:	50                   	push   %eax
   118b9:	ff 15 34 51 01 00    	call   *0x15134

  /* free the lock */
  NdisFreeSpinLock(&Adapter->Lock);
  
  /* free the adapter */
  NdisFreeMemory(Adapter, 0, 0);
   118bf:	59                   	pop    %ecx
   118c0:	5e                   	pop    %esi
   118c1:	6a 00                	push   $0x0
   118c3:	6a 00                	push   $0x0
   118c5:	53                   	push   %ebx
   118c6:	ff 15 18 51 01 00    	call   *0x15118
   118cc:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   118cf:	5b                   	pop    %ebx
   118d0:	5e                   	pop    %esi
   118d1:	5d                   	pop    %ebp
   118d2:	c2 04 00             	ret    $0x4
   118d5:	8d 74 26 00          	lea    0x0(%esi),%esi
   118d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000118e0 <_MiGetMediaState@4>:
}

BOOLEAN
STDCALL
MiSyncMediaDetection(
    IN PVOID SynchronizeContext)
/*
 * FUNCTION: Stop the adapter
 * ARGUMENTS:
 *     SynchronizeContext: Adapter context
 */
{
  PADAPTER Adapter = (PADAPTER)SynchronizeContext;
  NDIS_MEDIA_STATE MediaState = MiGetMediaState(Adapter);

  PCNET_DbgPrint(("Called\n"));
  PCNET_DbgPrint(("MediaState: %d\n", MediaState));
  if (MediaState != Adapter->MediaState)
    {
      Adapter->MediaState = MediaState;
      return TRUE;
    }
  return FALSE;
}
    
VOID
STDCALL
MiniportMediaDetectionTimer(
    IN PVOID SystemSpecific1,
    IN PVOID FunctionContext,
    IN PVOID SystemSpecific2,
    IN PVOID SystemSpecific3)
/*
 * FUNCTION: Periodially query media state
 * ARGUMENTS:
 *     FunctionContext: Adapter context
 * NOTES:
 *     - Called by NDIS at DISPATCH_LEVEL
 */
{
  PADAPTER Adapter = (PADAPTER)FunctionContext;

  if (NdisMSynchronizeWithInterrupt(&Adapter->InterruptObject,
                                    MiSyncMediaDetection,
                                    FunctionContext))
    {
      NdisMIndicateStatus(Adapter->MiniportAdapterHandle, 
        Adapter->MediaState == NdisMediaStateConnected ?
        NDIS_STATUS_MEDIA_CONNECT : NDIS_STATUS_MEDIA_DISCONNECT,
        (PVOID)0, 0);
      NdisMIndicateStatusComplete(Adapter->MiniportAdapterHandle);
    }
}
    
VOID
MiInitChip(
    PADAPTER Adapter)
/*
 * FUNCTION: Initialize and start the PCNET chip
 * ARGUMENTS:
 *     Adapter: pointer to the miniport's adapter struct
 * NOTES:
 *     - should be coded to detect failure and return an error
 *     - the vmware virtual lance chip doesn't support 32-bit i/o so don't do that.
 */
{
  USHORT Data = 0;

  PCNET_DbgPrint(("Called\n"));

  /*
   * first reset the chip - 32-bit reset followed by 16-bit reset.  if it's in 32-bit mode, it'll reset
   * twice.  if it's in 16-bit mode, the first read will be nonsense and the second will be a reset.  the
   * card is reset by reading from the reset register.  on reset it's in 16-bit i/o mode.
   */
  NdisRawReadPortUshort(Adapter->PortOffset + RESET32, &Data);
  NdisRawReadPortUshort(Adapter->PortOffset + RESET16, &Data);

  /* stop the chip */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STOP);

  /* pause for 1ms so the chip will have time to reset */
  NdisStallExecution(1);

  PCNET_DbgPrint(("chip stopped\n"));

  /* set the software style to 2 (32 bits) */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR58);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);

  Data |= SW_STYLE_2;

  NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);

  /* set up csr4: auto transmit pad, disable polling, disable transmit interrupt, dmaplus */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR4);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);

  Data |= CSR4_APAD_XMT | /* CSR4_DPOLL |*/ CSR4_TXSTRTM | CSR4_DMAPLUS;
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);

  /* set up bcr18: burst read/write enable */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR18);
  NdisRawReadPortUshort(Adapter->PortOffset + BDP, &Data);

  Data |= BCR18_BREADE | BCR18_BWRITE ;
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, Data);

  /* set up csr1 and csr2 with init block */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR1);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)((ULONG)Adapter->InitializationBlockPhys & 0xffff));
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR2);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)((ULONG)Adapter->InitializationBlockPhys >> 16) & 0xffff);

  PCNET_DbgPrint(("programmed with init block\n"));

  /* Set mode to 0 */
  Data = 0;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR15);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);

  /* load init block and start the card */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STRT|CSR0_INIT|CSR0_IENA);

  /* detect the media state */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR4);
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, BCR4_LNKSTE|BCR4_FDLSE);
  Adapter->MediaState = MiGetMediaState(Adapter);
  
  PCNET_DbgPrint(("card started\n"));

  Adapter->Flags &= ~RESET_IN_PROGRESS;
}

BOOLEAN
MiTestCard(
    PADAPTER Adapter)
/*
 * FUNCTION: Test the NIC
 * ARGUMENTS:
 *     Adapter: pointer to the miniport's adapter struct
 * RETURNS:
 *     TRUE if the test succeeds
 *     FALSE otherwise
 * NOTES:
 *     - this is where to add diagnostics.  This is called
 *       at the very end of initialization.
 */
{
  int i = 0;
  UCHAR address[6];
  USHORT Data = 0;

  /* see if we can read/write now */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
  PCNET_DbgPrint(("Port 0x%x RAP 0x%x CSR0 0x%x RDP 0x%x, Interupt status register is 0x%x\n", Adapter->PortOffset, RAP, CSR0, RDP, Data));

  /* read the BIA */
  for(i = 0; i < 6; i++)
      NdisRawReadPortUchar(Adapter->PortOffset + i, &address[i]);

  PCNET_DbgPrint(("burned-in address: %x:%x:%x:%x:%x:%x\n", address[0], address[1], address[2], address[3], address[4], address[5]));
  /* Read status flags from CSR0 */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
  PCNET_DbgPrint(("CSR0: 0x%x\n", Data));

  /* Read status flags from CSR3 */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR3);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);

  PCNET_DbgPrint(("CSR3: 0x%x\n", Data));
  /* Read status flags from CSR4 */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR4);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
  PCNET_DbgPrint(("CSR4: 0x%x\n", Data));

  /* Read status flags from CSR5 */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR5);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
  PCNET_DbgPrint(("CSR5: 0x%x\n", Data));

  /* Read status flags from CSR6 */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR6);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
  PCNET_DbgPrint(("CSR6: 0x%x\n", Data));

  return TRUE;
}

NDIS_STATUS
STDCALL
MiniportInitialize(
    OUT PNDIS_STATUS OpenErrorStatus,
    OUT PUINT SelectedMediumIndex,
    IN PNDIS_MEDIUM MediumArray,
    IN UINT MediumArraySize,
    IN NDIS_HANDLE MiniportAdapterHandle,
    IN NDIS_HANDLE WrapperConfigurationContext)
/*
 * FUNCTION:  Initialize a new miniport
 * ARGUMENTS:
 *     OpenErrorStatus:  pointer to a var to return status info in
 *     SelectedMediumIndex: index of the selected medium (will be NdisMedium802_3)
 *     MediumArray: array of media that we can pick from
 *     MediumArraySize: size of MediumArray
 *     MiniportAdapterHandle: NDIS-assigned handle for this miniport instance
 *     WrapperConfigurationContext: temporary NDIS-assigned handle for passing
 *                                  to configuration APIs
 * RETURNS:
 *     NDIS_STATUS_SUCCESS on success
 *     NDIS_STATUS_FAILURE on general failure
 *     NDIS_STATUS_UNSUPPORTED_MEDIA on not finding 802_3 in the MediaArray
 *     NDIS_STATUS_RESOURCES on insufficient system resources
 *     NDIS_STATUS_ADAPTER_NOT_FOUND on not finding the adapter
 * NOTES:
 *     - Called by NDIS at PASSIVE_LEVEL, once per detected card
 *     - Will int 3 on failure of MiTestCard if DBG=1
 */
{
  UINT i = 0;
  PADAPTER Adapter = 0;
  NDIS_STATUS Status = NDIS_STATUS_FAILURE;
  BOOLEAN InterruptRegistered = FALSE;

  /* Pick a medium */
  for(i = 0; i < MediumArraySize; i++)
    if(MediumArray[i] == NdisMedium802_3)
      break;

  if(i == MediumArraySize)
    {
      Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
      PCNET_DbgPrint(("unsupported media\n"));
      BREAKPOINT;
      *OpenErrorStatus = Status;
      return Status;
    }

  *SelectedMediumIndex = i;

  /* allocate our adapter struct */
  Status = NdisAllocateMemoryWithTag((PVOID *)&Adapter, sizeof(ADAPTER), PCNET_TAG);
  if(Status != NDIS_STATUS_SUCCESS)
    {
      Status =  NDIS_STATUS_RESOURCES;
      PCNET_DbgPrint(("Insufficient resources\n"));
      BREAKPOINT;
      *OpenErrorStatus = Status;
      return Status;
    }

  RtlZeroMemory(Adapter, sizeof(ADAPTER));

  Adapter->MiniportAdapterHandle = MiniportAdapterHandle;

  /* register our adapter structwith ndis */
  NdisMSetAttributesEx(Adapter->MiniportAdapterHandle, Adapter, 0, NDIS_ATTRIBUTE_BUS_MASTER, NdisInterfacePci);

  do
    {
      /* Card-specific detection and setup */
      Status = MiQueryCard(Adapter);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          PCNET_DbgPrint(("MiQueryCard failed\n"));
          Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
          BREAKPOINT;
          break;
        }

      /* register an IO port range */
      Status = NdisMRegisterIoPortRange(&Adapter->PortOffset, Adapter->MiniportAdapterHandle, 
          Adapter->IoBaseAddress, NUMBER_OF_PORTS);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          PCNET_DbgPrint(("NdisMRegisterIoPortRange failed: 0x%x\n", Status));
          BREAKPOINT
          break;
        }

      /* Allocate map registers */
      Status = NdisMAllocateMapRegisters(Adapter->MiniportAdapterHandle, 0, 
          NDIS_DMA_32BITS, 8, BUFFER_SIZE);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          PCNET_DbgPrint(("NdisMAllocateMapRegisters failed: 0x%x\n", Status));
          BREAKPOINT
          break;
        }

      /* set up the interrupt */
      Status = NdisMRegisterInterrupt(&Adapter->InterruptObject, Adapter->MiniportAdapterHandle, Adapter->InterruptVector,
          Adapter->InterruptVector, TRUE, TRUE, NdisInterruptLevelSensitive);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          PCNET_DbgPrint(("NdisMRegisterInterrupt failed: 0x%x\n", Status));
          BREAKPOINT
          break;
        }

      InterruptRegistered = TRUE;

      /* Allocate and initialize shared data structures */
      Status = MiAllocateSharedMemory(Adapter);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          Status = NDIS_STATUS_RESOURCES;
          PCNET_DbgPrint(("MiAllocateSharedMemory failed", Status));
          BREAKPOINT
          break;
        }

      /* set up the initialization block */
      MiPrepareInitializationBlock(Adapter);

      PCNET_DbgPrint(("Interrupt registered successfully\n"));

      /* Initialize and start the chip */
      MiInitChip(Adapter);

      NdisAllocateSpinLock(&Adapter->Lock);

      Status = NDIS_STATUS_SUCCESS;
    }
  while(0);

  if(Status != NDIS_STATUS_SUCCESS && Adapter)
    {
      PCNET_DbgPrint(("Error; freeing stuff\n"));

      NdisMFreeMapRegisters(Adapter->MiniportAdapterHandle); /* doesn't hurt to free if we never alloc'd? */

      if(Adapter->PortOffset)
        NdisMDeregisterIoPortRange(Adapter->MiniportAdapterHandle, Adapter->IoBaseAddress, NUMBER_OF_PORTS, Adapter->PortOffset);

      if(InterruptRegistered)
        NdisMDeregisterInterrupt(&Adapter->InterruptObject);

      MiFreeSharedMemory(Adapter);

      NdisFreeMemory(Adapter, 0, 0);
    }

  if(Status == NDIS_STATUS_SUCCESS)
    {
      NdisMInitializeTimer(&Adapter->MediaDetectionTimer,
                           Adapter->MiniportAdapterHandle,
                           MiniportMediaDetectionTimer,
                           Adapter);
      NdisMSetPeriodicTimer(&Adapter->MediaDetectionTimer,
                            MEDIA_DETECTION_INTERVAL);
    }

#if DBG
  if(!MiTestCard(Adapter))
    ASSERT(0);
#endif

  PCNET_DbgPrint(("returning 0x%x\n", Status));
  *OpenErrorStatus = Status;
  return Status;
}

VOID
STDCALL
MiniportISR(
    OUT PBOOLEAN InterruptRecognized,
    OUT PBOOLEAN QueueMiniportHandleInterrupt,
    IN NDIS_HANDLE MiniportAdapterContext)
/*
 * FUNCTION: Miniport interrupt service routine
 * ARGUMENTS:
 *     InterruptRecognized: the interrupt was ours
 *     QueueMiniportHandleInterrupt: whether to queue a DPC to handle this interrupt
 *     MiniportAdapterContext: the context originally passed to NdisMSetAttributes
 * NOTES:
 *     - called by NDIS at DIRQL
 *     - by setting QueueMiniportHandleInterrupt to TRUE, MiniportHandleInterrupt
 *       will be called
 */
{
  USHORT Data;
  USHORT Rap;
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;

  PCNET_DbgPrint(("Called\n"));

  /* save the old RAP value */
  NdisRawReadPortUshort(Adapter->PortOffset + RAP, &Rap);

  /* is this ours? */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);

  if(!(Data & CSR0_INTR))
    {
      PCNET_DbgPrint(("not our interrupt.\n"));
      *InterruptRecognized = FALSE;
      *QueueMiniportHandleInterrupt = FALSE;
    }
  else
    {
      PCNET_DbgPrint(("detected our interrupt\n"));

      /* disable interrupts */
      NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
      NdisRawWritePortUshort(Adapter->PortOffset + RDP, 0);

      *InterruptRecognized = TRUE;
      *QueueMiniportHandleInterrupt = TRUE;
    }

  /* restore the rap */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, Rap);
}

NDIS_STATUS
STDCALL
MiniportReset(
    OUT PBOOLEAN AddressingReset,
    IN NDIS_HANDLE MiniportAdapterContext)
/*
 * FUNCTION: Reset the miniport
 * ARGUMENTS:
 *     AddressingReset: Whether or not we want NDIS to subsequently call MiniportSetInformation
 *                      to reset our addresses and filters
 *     MiniportAdapterContext: context originally passed to NdisMSetAttributes
 * RETURNS:
 *     NDIS_STATUS_SUCCESS on all requests
 * Notes:
 *     - Called by NDIS at PASSIVE_LEVEL when it thinks we need a reset
 */
{
  PCNET_DbgPrint(("Called\n"));

  /* MiniportReset doesn't do anything at the moment... perhaps this should be fixed. */

  *AddressingReset = FALSE;
  return NDIS_STATUS_SUCCESS;
}

BOOLEAN
STDCALL
MiSyncStartTransmit(
    IN PVOID SynchronizeContext)
/*
 * FUNCTION: Stop the adapter
 * ARGUMENTS:
 *     SynchronizeContext: Adapter context
 */
{
  PADAPTER Adapter = (PADAPTER)SynchronizeContext;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_IENA | CSR0_TDMD);
  return TRUE;
}
    
NDIS_STATUS
STDCALL
MiniportSend(
    IN NDIS_HANDLE MiniportAdapterContext,
    IN PNDIS_PACKET Packet,
    IN UINT Flags)
/*
 * FUNCTION: Called by NDIS when it has a packet for the NIC to send out
 * ARGUMENTS:
 *     MiniportAdapterContext: context originally input to NdisMSetAttributes
 *     Packet: The NDIS_PACKET to be sent
 *     Flags: Flags associated with Packet
 * RETURNS:
 *     NDIS_STATUS_SUCCESS on processed requests
 *     NDIS_STATUS_RESOURCES if there's no place in buffer ring
 * NOTES:
 *     - Called by NDIS at DISPATCH_LEVEL
 */
{
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
  PTRANSMIT_DESCRIPTOR Desc;
  PNDIS_BUFFER NdisBuffer;
  PVOID SourceBuffer;
  UINT TotalPacketLength, SourceLength, Position = 0;

  PCNET_DbgPrint(("Called\n"));

  NdisDprAcquireSpinLock(&Adapter->Lock);

  /* Check if we have free entry in our circular buffer. */
  if ((Adapter->CurrentTransmitEndIndex + 1 ==
       Adapter->CurrentTransmitStartIndex) ||
      (Adapter->CurrentTransmitEndIndex == NUMBER_OF_BUFFERS - 1 &&
       Adapter->CurrentTransmitStartIndex == 0))
    {
      PCNET_DbgPrint(("No free space in circular buffer\n"));
      NdisDprReleaseSpinLock(&Adapter->Lock);
      return NDIS_STATUS_RESOURCES;
    }

  Desc = Adapter->TransmitDescriptorRingVirt + Adapter->CurrentTransmitEndIndex;

  NdisQueryPacket(Packet, NULL, NULL, &NdisBuffer, &TotalPacketLength);
  ASSERT(TotalPacketLength <= BUFFER_SIZE);

  PCNET_DbgPrint(("TotalPacketLength: %x\n", TotalPacketLength));

  while (NdisBuffer)
    {
      NdisQueryBuffer(NdisBuffer, &SourceBuffer, &SourceLength);

      PCNET_DbgPrint(("Buffer: %x Length: %x\n", SourceBuffer, SourceLength));

      RtlCopyMemory(Adapter->TransmitBufferPtrVirt +
                    Adapter->CurrentTransmitEndIndex * BUFFER_SIZE + Position,
                    SourceBuffer, SourceLength);

      Position += SourceLength;
            
      NdisGetNextBuffer(NdisBuffer, &NdisBuffer);
    }

#if DBG && 0
  {
    PUCHAR Ptr = Adapter->TransmitBufferPtrVirt +
                 Adapter->CurrentTransmitEndIndex * BUFFER_SIZE;
    for (Position = 0; Position < TotalPacketLength; Position++)
      {
        if (Position % 16 == 0)
          DbgPrint("\n");
        DbgPrint("%x ", *Ptr++);
      }
  }
  DbgPrint("\n");
#endif

  Adapter->CurrentTransmitEndIndex++;
  Adapter->CurrentTransmitEndIndex %= NUMBER_OF_BUFFERS;

  Desc->FLAGS = TD1_OWN | TD1_STP | TD1_ENP;
  Desc->BCNT = 0xf000 | -TotalPacketLength;

  NdisMSynchronizeWithInterrupt(&Adapter->InterruptObject, MiSyncStartTransmit, Adapter);

  NdisDprReleaseSpinLock(&Adapter->Lock);

  return NDIS_STATUS_SUCCESS;
}

ULONG
STDCALL
MiEthernetCrc(UCHAR *Address)
/*
 * FUNCTION: Calculate Ethernet CRC32
 * ARGUMENTS:
 *     Address: 6-byte ethernet address
 * RETURNS:
 *     The calculated CRC32 value.
 */
{
  UINT Counter, Length;
  ULONG Value = ~0;

  for (Length = 0; Length < 6; Length++)
    {
      Value ^= *Address++;
      for (Counter = 0; Counter < 8; Counter++)
        {
          Value >>= 1;
          Value ^= (Value & 1) * 0xedb88320;
        }
    }

  return Value;
}

NDIS_STATUS
STDCALL
MiSetMulticast(
    PADAPTER Adapter,
    UCHAR *Addresses,
    UINT AddressCount)
{
  UINT Index;
  ULONG CrcIndex;

  NdisZeroMemory(Adapter->InitializationBlockVirt->LADR, 8);
  for (Index = 0; Index < AddressCount; Index++)
    {
      CrcIndex = MiEthernetCrc(Addresses) >> 26;
      Adapter->InitializationBlockVirt->LADR[CrcIndex >> 3] |= 1 << (CrcIndex & 15);
      Addresses += 6;
    }

  /* FIXME: The specification mentions we need to reload the init block here. */

  return NDIS_STATUS_SUCCESS;
}

NDIS_MEDIA_STATE
STDCALL
MiGetMediaState(PADAPTER Adapter)
/*
 * FUNCTION: Determine the link state
 * ARGUMENTS:
 *     Adapter: Adapter context
 * RETURNS:
 *     NdisMediaStateConnected if the cable is connected
 *     NdisMediaStateDisconnected if the cable is disconnected
 */
{
   118e0:	55                   	push   %ebp
   118e1:	89 e5                	mov    %esp,%ebp
   118e3:	53                   	push   %ebx
   118e4:	83 ec 0c             	sub    $0xc,%esp
   118e7:	8b 5d 08             	mov    0x8(%ebp),%ebx
  ULONG Data;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR4);
   118ea:	6a 04                	push   $0x4
   118ec:	8b 43 18             	mov    0x18(%ebx),%eax
   118ef:	83 c0 12             	add    $0x12,%eax
   118f2:	50                   	push   %eax
   118f3:	ff 15 04 51 01 00    	call   *0x15104
  NdisRawReadPortUshort(Adapter->PortOffset + BDP, &Data);
   118f9:	52                   	push   %edx
   118fa:	8b 43 18             	mov    0x18(%ebx),%eax
   118fd:	83 c0 16             	add    $0x16,%eax
   11900:	50                   	push   %eax
   11901:	ff 15 00 51 01 00    	call   *0x15100
  return Data & BCR4_LEDOUT ? NdisMediaStateConnected : NdisMediaStateDisconnected;
   11907:	83 c4 0c             	add    $0xc,%esp
   1190a:	66 a9 00 80          	test   $0x8000,%ax
   1190e:	0f 94 c0             	sete   %al
   11911:	25 ff 00 00 00       	and    $0xff,%eax
}
   11916:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11919:	c9                   	leave  
   1191a:	c2 04 00             	ret    $0x4
   1191d:	8d 76 00             	lea    0x0(%esi),%esi

00011920 <_MiSyncMediaDetection@4>:
   11920:	55                   	push   %ebp
   11921:	89 e5                	mov    %esp,%ebp
   11923:	53                   	push   %ebx
   11924:	83 ec 10             	sub    $0x10,%esp
   11927:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1192a:	53                   	push   %ebx
   1192b:	e8 b0 ff ff ff       	call   118e0 <_MiGetMediaState@4>
   11930:	31 d2                	xor    %edx,%edx
   11932:	83 c4 0c             	add    $0xc,%esp
   11935:	39 43 6c             	cmp    %eax,0x6c(%ebx)
   11938:	74 05                	je     1193f <_MiSyncMediaDetection@4+0x1f>
   1193a:	89 43 6c             	mov    %eax,0x6c(%ebx)
   1193d:	b2 01                	mov    $0x1,%dl
   1193f:	89 d0                	mov    %edx,%eax
   11941:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11944:	c9                   	leave  
   11945:	c2 04 00             	ret    $0x4
   11948:	90                   	nop    
   11949:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011950 <_MiniportMediaDetectionTimer@16>:
   11950:	55                   	push   %ebp
   11951:	89 e5                	mov    %esp,%ebp
   11953:	53                   	push   %ebx
   11954:	53                   	push   %ebx
   11955:	53                   	push   %ebx
   11956:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11959:	53                   	push   %ebx
   1195a:	68 20 19 01 00       	push   $0x11920
   1195f:	8d 43 1c             	lea    0x1c(%ebx),%eax
   11962:	50                   	push   %eax
   11963:	ff 15 54 51 01 00    	call   *0x15154
   11969:	59                   	pop    %ecx
   1196a:	84 c0                	test   %al,%al
   1196c:	74 2c                	je     1199a <_MiniportMediaDetectionTimer@16+0x4a>
   1196e:	8b 53 08             	mov    0x8(%ebx),%edx
   11971:	6a 00                	push   $0x0
   11973:	6a 00                	push   $0x0
   11975:	8b 43 6c             	mov    0x6c(%ebx),%eax
   11978:	83 f8 01             	cmp    $0x1,%eax
   1197b:	19 c0                	sbb    %eax,%eax
   1197d:	05 0c 00 01 40       	add    $0x4001000c,%eax
   11982:	50                   	push   %eax
   11983:	52                   	push   %edx
   11984:	ff 92 7c 01 00 00    	call   *0x17c(%edx)
   1198a:	8b 43 08             	mov    0x8(%ebx),%eax
   1198d:	83 ec 0c             	sub    $0xc,%esp
   11990:	50                   	push   %eax
   11991:	ff 90 80 01 00 00    	call   *0x180(%eax)
   11997:	83 c4 0c             	add    $0xc,%esp
   1199a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1199d:	c9                   	leave  
   1199e:	c2 10 00             	ret    $0x10
   119a1:	eb 0d                	jmp    119b0 <_MiInitChip>
   119a3:	90                   	nop    
   119a4:	90                   	nop    
   119a5:	90                   	nop    
   119a6:	90                   	nop    
   119a7:	90                   	nop    
   119a8:	90                   	nop    
   119a9:	90                   	nop    
   119aa:	90                   	nop    
   119ab:	90                   	nop    
   119ac:	90                   	nop    
   119ad:	90                   	nop    
   119ae:	90                   	nop    
   119af:	90                   	nop    

000119b0 <_MiInitChip>:
   119b0:	55                   	push   %ebp
   119b1:	89 e5                	mov    %esp,%ebp
   119b3:	53                   	push   %ebx
   119b4:	83 ec 10             	sub    $0x10,%esp
   119b7:	8b 5d 08             	mov    0x8(%ebp),%ebx
   119ba:	8b 43 18             	mov    0x18(%ebx),%eax
   119bd:	83 c0 18             	add    $0x18,%eax
   119c0:	50                   	push   %eax
   119c1:	ff 15 00 51 01 00    	call   *0x15100
   119c7:	8b 43 18             	mov    0x18(%ebx),%eax
   119ca:	83 c0 14             	add    $0x14,%eax
   119cd:	50                   	push   %eax
   119ce:	ff 15 00 51 01 00    	call   *0x15100
   119d4:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   119db:	8b 43 18             	mov    0x18(%ebx),%eax
   119de:	83 c0 12             	add    $0x12,%eax
   119e1:	50                   	push   %eax
   119e2:	ff 15 04 51 01 00    	call   *0x15104
   119e8:	6a 04                	push   $0x4
   119ea:	8b 43 18             	mov    0x18(%ebx),%eax
   119ed:	83 c0 10             	add    $0x10,%eax
   119f0:	50                   	push   %eax
   119f1:	ff 15 04 51 01 00    	call   *0x15104
   119f7:	50                   	push   %eax
   119f8:	6a 01                	push   $0x1
   119fa:	ff 15 f8 50 01 00    	call   *0x150f8
   11a00:	c7 04 24 3a 00 00 00 	movl   $0x3a,(%esp)
   11a07:	8b 43 18             	mov    0x18(%ebx),%eax
   11a0a:	83 c0 12             	add    $0x12,%eax
   11a0d:	50                   	push   %eax
   11a0e:	ff 15 04 51 01 00    	call   *0x15104
   11a14:	50                   	push   %eax
   11a15:	8b 43 18             	mov    0x18(%ebx),%eax
   11a18:	83 c0 10             	add    $0x10,%eax
   11a1b:	50                   	push   %eax
   11a1c:	ff 15 00 51 01 00    	call   *0x15100
   11a22:	83 c8 02             	or     $0x2,%eax
   11a25:	25 ff ff 00 00       	and    $0xffff,%eax
   11a2a:	89 04 24             	mov    %eax,(%esp)
   11a2d:	8b 43 18             	mov    0x18(%ebx),%eax
   11a30:	83 c0 10             	add    $0x10,%eax
   11a33:	50                   	push   %eax
   11a34:	ff 15 04 51 01 00    	call   *0x15104
   11a3a:	6a 04                	push   $0x4
   11a3c:	8b 43 18             	mov    0x18(%ebx),%eax
   11a3f:	83 c0 12             	add    $0x12,%eax
   11a42:	50                   	push   %eax
   11a43:	ff 15 04 51 01 00    	call   *0x15104
   11a49:	50                   	push   %eax
   11a4a:	8b 43 18             	mov    0x18(%ebx),%eax
   11a4d:	83 c0 10             	add    $0x10,%eax
   11a50:	50                   	push   %eax
   11a51:	ff 15 00 51 01 00    	call   *0x15100
   11a57:	0d 04 48 00 00       	or     $0x4804,%eax
   11a5c:	25 ff ff 00 00       	and    $0xffff,%eax
   11a61:	89 04 24             	mov    %eax,(%esp)
   11a64:	8b 43 18             	mov    0x18(%ebx),%eax
   11a67:	83 c0 10             	add    $0x10,%eax
   11a6a:	50                   	push   %eax
   11a6b:	ff 15 04 51 01 00    	call   *0x15104
   11a71:	6a 12                	push   $0x12
   11a73:	8b 43 18             	mov    0x18(%ebx),%eax
   11a76:	83 c0 12             	add    $0x12,%eax
   11a79:	50                   	push   %eax
   11a7a:	ff 15 04 51 01 00    	call   *0x15104
   11a80:	50                   	push   %eax
   11a81:	8b 43 18             	mov    0x18(%ebx),%eax
   11a84:	83 c0 16             	add    $0x16,%eax
   11a87:	50                   	push   %eax
   11a88:	ff 15 00 51 01 00    	call   *0x15100
   11a8e:	83 c8 60             	or     $0x60,%eax
   11a91:	25 ff ff 00 00       	and    $0xffff,%eax
   11a96:	89 04 24             	mov    %eax,(%esp)
   11a99:	8b 43 18             	mov    0x18(%ebx),%eax
   11a9c:	83 c0 16             	add    $0x16,%eax
   11a9f:	50                   	push   %eax
   11aa0:	ff 15 04 51 01 00    	call   *0x15104
   11aa6:	6a 01                	push   $0x1
   11aa8:	8b 43 18             	mov    0x18(%ebx),%eax
   11aab:	83 c0 12             	add    $0x12,%eax
   11aae:	50                   	push   %eax
   11aaf:	ff 15 04 51 01 00    	call   *0x15104
   11ab5:	66 8b 83 e4 00 00 00 	mov    0xe4(%ebx),%ax
   11abc:	25 ff ff 00 00       	and    $0xffff,%eax
   11ac1:	50                   	push   %eax
   11ac2:	8b 43 18             	mov    0x18(%ebx),%eax
   11ac5:	83 c0 10             	add    $0x10,%eax
   11ac8:	50                   	push   %eax
   11ac9:	ff 15 04 51 01 00    	call   *0x15104
   11acf:	6a 02                	push   $0x2
   11ad1:	8b 43 18             	mov    0x18(%ebx),%eax
   11ad4:	83 c0 12             	add    $0x12,%eax
   11ad7:	50                   	push   %eax
   11ad8:	ff 15 04 51 01 00    	call   *0x15104
   11ade:	8b 83 e4 00 00 00    	mov    0xe4(%ebx),%eax
   11ae4:	c1 e8 10             	shr    $0x10,%eax
   11ae7:	50                   	push   %eax
   11ae8:	8b 43 18             	mov    0x18(%ebx),%eax
   11aeb:	83 c0 10             	add    $0x10,%eax
   11aee:	50                   	push   %eax
   11aef:	ff 15 04 51 01 00    	call   *0x15104
   11af5:	6a 0f                	push   $0xf
   11af7:	8b 43 18             	mov    0x18(%ebx),%eax
   11afa:	83 c0 12             	add    $0x12,%eax
   11afd:	50                   	push   %eax
   11afe:	ff 15 04 51 01 00    	call   *0x15104
   11b04:	6a 00                	push   $0x0
   11b06:	8b 43 18             	mov    0x18(%ebx),%eax
   11b09:	83 c0 10             	add    $0x10,%eax
   11b0c:	50                   	push   %eax
   11b0d:	ff 15 04 51 01 00    	call   *0x15104
   11b13:	6a 00                	push   $0x0
   11b15:	8b 43 18             	mov    0x18(%ebx),%eax
   11b18:	83 c0 12             	add    $0x12,%eax
   11b1b:	50                   	push   %eax
   11b1c:	ff 15 04 51 01 00    	call   *0x15104
   11b22:	6a 43                	push   $0x43
   11b24:	8b 43 18             	mov    0x18(%ebx),%eax
   11b27:	83 c0 10             	add    $0x10,%eax
   11b2a:	50                   	push   %eax
   11b2b:	ff 15 04 51 01 00    	call   *0x15104
   11b31:	6a 04                	push   $0x4
   11b33:	8b 43 18             	mov    0x18(%ebx),%eax
   11b36:	83 c0 12             	add    $0x12,%eax
   11b39:	50                   	push   %eax
   11b3a:	ff 15 04 51 01 00    	call   *0x15104
   11b40:	68 40 01 00 00       	push   $0x140
   11b45:	8b 43 18             	mov    0x18(%ebx),%eax
   11b48:	83 c0 16             	add    $0x16,%eax
   11b4b:	50                   	push   %eax
   11b4c:	ff 15 04 51 01 00    	call   *0x15104
   11b52:	50                   	push   %eax
   11b53:	53                   	push   %ebx
   11b54:	e8 87 fd ff ff       	call   118e0 <_MiGetMediaState@4>
   11b59:	89 43 6c             	mov    %eax,0x6c(%ebx)
   11b5c:	8b 43 0c             	mov    0xc(%ebx),%eax
   11b5f:	83 e0 fe             	and    $0xfffffffe,%eax
   11b62:	89 43 0c             	mov    %eax,0xc(%ebx)
   11b65:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11b68:	c9                   	leave  
   11b69:	c3                   	ret    
   11b6a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011b70 <_MiTestCard>:
   11b70:	55                   	push   %ebp
   11b71:	89 e5                	mov    %esp,%ebp
   11b73:	56                   	push   %esi
   11b74:	53                   	push   %ebx
   11b75:	31 db                	xor    %ebx,%ebx
   11b77:	83 ec 18             	sub    $0x18,%esp
   11b7a:	8b 75 08             	mov    0x8(%ebp),%esi
   11b7d:	6a 00                	push   $0x0
   11b7f:	8b 46 18             	mov    0x18(%esi),%eax
   11b82:	83 c0 12             	add    $0x12,%eax
   11b85:	50                   	push   %eax
   11b86:	ff 15 04 51 01 00    	call   *0x15104
   11b8c:	50                   	push   %eax
   11b8d:	8b 46 18             	mov    0x18(%esi),%eax
   11b90:	83 c0 10             	add    $0x10,%eax
   11b93:	50                   	push   %eax
   11b94:	ff 15 00 51 01 00    	call   *0x15100
   11b9a:	83 c4 0c             	add    $0xc,%esp
   11b9d:	8d 76 00             	lea    0x0(%esi),%esi
   11ba0:	83 ec 0c             	sub    $0xc,%esp
   11ba3:	8b 46 18             	mov    0x18(%esi),%eax
   11ba6:	01 d8                	add    %ebx,%eax
   11ba8:	50                   	push   %eax
   11ba9:	ff 15 fc 50 01 00    	call   *0x150fc
   11baf:	83 c4 0c             	add    $0xc,%esp
   11bb2:	88 44 2b e8          	mov    %al,0xffffffe8(%ebx,%ebp,1)
   11bb6:	43                   	inc    %ebx
   11bb7:	83 fb 05             	cmp    $0x5,%ebx
   11bba:	7e e4                	jle    11ba0 <_MiTestCard+0x30>
   11bbc:	50                   	push   %eax
   11bbd:	50                   	push   %eax
   11bbe:	6a 00                	push   $0x0
   11bc0:	8b 46 18             	mov    0x18(%esi),%eax
   11bc3:	83 c0 12             	add    $0x12,%eax
   11bc6:	50                   	push   %eax
   11bc7:	ff 15 04 51 01 00    	call   *0x15104
   11bcd:	50                   	push   %eax
   11bce:	8b 46 18             	mov    0x18(%esi),%eax
   11bd1:	83 c0 10             	add    $0x10,%eax
   11bd4:	50                   	push   %eax
   11bd5:	ff 15 00 51 01 00    	call   *0x15100
   11bdb:	c7 04 24 03 00 00 00 	movl   $0x3,(%esp)
   11be2:	8b 46 18             	mov    0x18(%esi),%eax
   11be5:	83 c0 12             	add    $0x12,%eax
   11be8:	50                   	push   %eax
   11be9:	ff 15 04 51 01 00    	call   *0x15104
   11bef:	50                   	push   %eax
   11bf0:	8b 46 18             	mov    0x18(%esi),%eax
   11bf3:	83 c0 10             	add    $0x10,%eax
   11bf6:	50                   	push   %eax
   11bf7:	ff 15 00 51 01 00    	call   *0x15100
   11bfd:	c7 04 24 04 00 00 00 	movl   $0x4,(%esp)
   11c04:	8b 46 18             	mov    0x18(%esi),%eax
   11c07:	83 c0 12             	add    $0x12,%eax
   11c0a:	50                   	push   %eax
   11c0b:	ff 15 04 51 01 00    	call   *0x15104
   11c11:	53                   	push   %ebx
   11c12:	8b 46 18             	mov    0x18(%esi),%eax
   11c15:	83 c0 10             	add    $0x10,%eax
   11c18:	50                   	push   %eax
   11c19:	ff 15 00 51 01 00    	call   *0x15100
   11c1f:	c7 04 24 05 00 00 00 	movl   $0x5,(%esp)
   11c26:	8b 46 18             	mov    0x18(%esi),%eax
   11c29:	83 c0 12             	add    $0x12,%eax
   11c2c:	50                   	push   %eax
   11c2d:	ff 15 04 51 01 00    	call   *0x15104
   11c33:	51                   	push   %ecx
   11c34:	8b 46 18             	mov    0x18(%esi),%eax
   11c37:	83 c0 10             	add    $0x10,%eax
   11c3a:	50                   	push   %eax
   11c3b:	ff 15 00 51 01 00    	call   *0x15100
   11c41:	c7 04 24 06 00 00 00 	movl   $0x6,(%esp)
   11c48:	8b 46 18             	mov    0x18(%esi),%eax
   11c4b:	83 c0 12             	add    $0x12,%eax
   11c4e:	50                   	push   %eax
   11c4f:	ff 15 04 51 01 00    	call   *0x15104
   11c55:	52                   	push   %edx
   11c56:	8b 46 18             	mov    0x18(%esi),%eax
   11c59:	83 c0 10             	add    $0x10,%eax
   11c5c:	50                   	push   %eax
   11c5d:	ff 15 00 51 01 00    	call   *0x15100
   11c63:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11c66:	b8 01 00 00 00       	mov    $0x1,%eax
   11c6b:	5b                   	pop    %ebx
   11c6c:	5e                   	pop    %esi
   11c6d:	5d                   	pop    %ebp
   11c6e:	c3                   	ret    
   11c6f:	90                   	nop    

00011c70 <_MiniportInitialize@24>:
   11c70:	55                   	push   %ebp
   11c71:	31 d2                	xor    %edx,%edx
   11c73:	89 e5                	mov    %esp,%ebp
   11c75:	57                   	push   %edi
   11c76:	56                   	push   %esi
   11c77:	53                   	push   %ebx
   11c78:	83 ec 0c             	sub    $0xc,%esp
   11c7b:	31 ff                	xor    %edi,%edi
   11c7d:	8b 45 14             	mov    0x14(%ebp),%eax
   11c80:	8b 75 08             	mov    0x8(%ebp),%esi
   11c83:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11c86:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   11c8d:	39 c2                	cmp    %eax,%edx
   11c8f:	73 0c                	jae    11c9d <_MiniportInitialize@24+0x2d>
   11c91:	8b 1c 91             	mov    (%ecx,%edx,4),%ebx
   11c94:	85 db                	test   %ebx,%ebx
   11c96:	74 05                	je     11c9d <_MiniportInitialize@24+0x2d>
   11c98:	42                   	inc    %edx
   11c99:	39 c2                	cmp    %eax,%edx
   11c9b:	72 f4                	jb     11c91 <_MiniportInitialize@24+0x21>
   11c9d:	39 c2                	cmp    %eax,%edx
   11c9f:	75 15                	jne    11cb6 <_MiniportInitialize@24+0x46>
   11ca1:	c7 06 19 00 01 c0    	movl   $0xc0010019,(%esi)
   11ca7:	b8 19 00 01 c0       	mov    $0xc0010019,%eax
   11cac:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11caf:	5b                   	pop    %ebx
   11cb0:	5e                   	pop    %esi
   11cb1:	5f                   	pop    %edi
   11cb2:	5d                   	pop    %ebp
   11cb3:	c2 18 00             	ret    $0x18
   11cb6:	8b 45 0c             	mov    0xc(%ebp),%eax
   11cb9:	89 10                	mov    %edx,(%eax)
   11cbb:	50                   	push   %eax
   11cbc:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11cbf:	68 0d f0 ad ba       	push   $0xbaadf00d
   11cc4:	68 58 01 00 00       	push   $0x158
   11cc9:	50                   	push   %eax
   11cca:	ff 15 14 51 01 00    	call   *0x15114
   11cd0:	89 c3                	mov    %eax,%ebx
   11cd2:	58                   	pop    %eax
   11cd3:	85 db                	test   %ebx,%ebx
   11cd5:	74 15                	je     11cec <_MiniportInitialize@24+0x7c>
   11cd7:	c7 06 9a 00 00 c0    	movl   $0xc000009a,(%esi)
   11cdd:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   11ce2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11ce5:	5b                   	pop    %ebx
   11ce6:	5e                   	pop    %esi
   11ce7:	5f                   	pop    %edi
   11ce8:	5d                   	pop    %ebp
   11ce9:	c2 18 00             	ret    $0x18
   11cec:	50                   	push   %eax
   11ced:	68 58 01 00 00       	push   $0x158
   11cf2:	6a 00                	push   $0x0
   11cf4:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11cf7:	50                   	push   %eax
   11cf8:	e8 33 0d 00 00       	call   12a30 <_memset>
   11cfd:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11d00:	8b 45 18             	mov    0x18(%ebp),%eax
   11d03:	89 42 08             	mov    %eax,0x8(%edx)
   11d06:	c7 04 24 05 00 00 00 	movl   $0x5,(%esp)
   11d0d:	6a 08                	push   $0x8
   11d0f:	6a 00                	push   $0x0
   11d11:	52                   	push   %edx
   11d12:	50                   	push   %eax
   11d13:	ff 15 4c 51 01 00    	call   *0x1514c
   11d19:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   11d1c:	53                   	push   %ebx
   11d1d:	e8 3e f6 ff ff       	call   11360 <_MiQueryCard>
   11d22:	83 c4 10             	add    $0x10,%esp
   11d25:	85 c0                	test   %eax,%eax
   11d27:	74 52                	je     11d7b <_MiniportInitialize@24+0x10b>
   11d29:	bb 06 00 01 c0       	mov    $0xc0010006,%ebx
   11d2e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d31:	85 c0                	test   %eax,%eax
   11d33:	0f 85 d7 00 00 00    	jne    11e10 <_MiniportInitialize@24+0x1a0>
   11d39:	85 db                	test   %ebx,%ebx
   11d3b:	75 30                	jne    11d6d <_MiniportInitialize@24+0xfd>
   11d3d:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d40:	50                   	push   %eax
   11d41:	68 50 19 01 00       	push   $0x11950
   11d46:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d49:	8b 78 08             	mov    0x8(%eax),%edi
   11d4c:	83 c0 70             	add    $0x70,%eax
   11d4f:	57                   	push   %edi
   11d50:	50                   	push   %eax
   11d51:	ff 15 3c 51 01 00    	call   *0x1513c
   11d57:	51                   	push   %ecx
   11d58:	51                   	push   %ecx
   11d59:	68 88 13 00 00       	push   $0x1388
   11d5e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d61:	83 c0 70             	add    $0x70,%eax
   11d64:	50                   	push   %eax
   11d65:	ff 15 50 51 01 00    	call   *0x15150
   11d6b:	58                   	pop    %eax
   11d6c:	5a                   	pop    %edx
   11d6d:	89 1e                	mov    %ebx,(%esi)
   11d6f:	89 d8                	mov    %ebx,%eax
   11d71:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11d74:	5b                   	pop    %ebx
   11d75:	5e                   	pop    %esi
   11d76:	5f                   	pop    %edi
   11d77:	5d                   	pop    %ebp
   11d78:	c2 18 00             	ret    $0x18
   11d7b:	6a 20                	push   $0x20
   11d7d:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d80:	8b 48 14             	mov    0x14(%eax),%ecx
   11d83:	51                   	push   %ecx
   11d84:	8b 50 08             	mov    0x8(%eax),%edx
   11d87:	83 c0 18             	add    $0x18,%eax
   11d8a:	52                   	push   %edx
   11d8b:	50                   	push   %eax
   11d8c:	ff 15 44 51 01 00    	call   *0x15144
   11d92:	89 c3                	mov    %eax,%ebx
   11d94:	85 c0                	test   %eax,%eax
   11d96:	75 96                	jne    11d2e <_MiniportInitialize@24+0xbe>
   11d98:	83 ec 0c             	sub    $0xc,%esp
   11d9b:	68 00 06 00 00       	push   $0x600
   11da0:	6a 08                	push   $0x8
   11da2:	6a 01                	push   $0x1
   11da4:	6a 00                	push   $0x0
   11da6:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11da9:	8b 40 08             	mov    0x8(%eax),%eax
   11dac:	50                   	push   %eax
   11dad:	ff 15 20 51 01 00    	call   *0x15120
   11db3:	83 c4 0c             	add    $0xc,%esp
   11db6:	89 c3                	mov    %eax,%ebx
   11db8:	85 c0                	test   %eax,%eax
   11dba:	0f 85 6e ff ff ff    	jne    11d2e <_MiniportInitialize@24+0xbe>
   11dc0:	50                   	push   %eax
   11dc1:	6a 00                	push   $0x0
   11dc3:	6a 01                	push   $0x1
   11dc5:	6a 01                	push   $0x1
   11dc7:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11dca:	8b 58 10             	mov    0x10(%eax),%ebx
   11dcd:	53                   	push   %ebx
   11dce:	8b 48 10             	mov    0x10(%eax),%ecx
   11dd1:	51                   	push   %ecx
   11dd2:	8b 50 08             	mov    0x8(%eax),%edx
   11dd5:	83 c0 1c             	add    $0x1c,%eax
   11dd8:	52                   	push   %edx
   11dd9:	50                   	push   %eax
   11dda:	ff 15 40 51 01 00    	call   *0x15140
   11de0:	89 c3                	mov    %eax,%ebx
   11de2:	58                   	pop    %eax
   11de3:	85 db                	test   %ebx,%ebx
   11de5:	0f 85 43 ff ff ff    	jne    11d2e <_MiniportInitialize@24+0xbe>
   11deb:	83 ec 0c             	sub    $0xc,%esp
   11dee:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11df1:	bf 01 00 00 00       	mov    $0x1,%edi
   11df6:	50                   	push   %eax
   11df7:	e8 44 f6 ff ff       	call   11440 <_MiAllocateSharedMemory>
   11dfc:	83 c4 10             	add    $0x10,%esp
   11dff:	89 c3                	mov    %eax,%ebx
   11e01:	85 c0                	test   %eax,%eax
   11e03:	74 76                	je     11e7b <_MiniportInitialize@24+0x20b>
   11e05:	bb 9a 00 00 c0       	mov    $0xc000009a,%ebx
   11e0a:	e9 1f ff ff ff       	jmp    11d2e <_MiniportInitialize@24+0xbe>
   11e0f:	90                   	nop    
   11e10:	83 ec 0c             	sub    $0xc,%esp
   11e13:	8b 48 08             	mov    0x8(%eax),%ecx
   11e16:	51                   	push   %ecx
   11e17:	ff 15 34 51 01 00    	call   *0x15134
   11e1d:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11e20:	83 c4 0c             	add    $0xc,%esp
   11e23:	8b 50 18             	mov    0x18(%eax),%edx
   11e26:	85 d2                	test   %edx,%edx
   11e28:	75 29                	jne    11e53 <_MiniportInitialize@24+0x1e3>
   11e2a:	89 f8                	mov    %edi,%eax
   11e2c:	84 c0                	test   %al,%al
   11e2e:	75 36                	jne    11e66 <_MiniportInitialize@24+0x1f6>
   11e30:	83 ec 0c             	sub    $0xc,%esp
   11e33:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11e36:	50                   	push   %eax
   11e37:	e8 a4 f8 ff ff       	call   116e0 <_MiFreeSharedMemory>
   11e3c:	83 c4 0c             	add    $0xc,%esp
   11e3f:	6a 00                	push   $0x0
   11e41:	6a 00                	push   $0x0
   11e43:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11e46:	50                   	push   %eax
   11e47:	ff 15 18 51 01 00    	call   *0x15118
   11e4d:	58                   	pop    %eax
   11e4e:	e9 e6 fe ff ff       	jmp    11d39 <_MiniportInitialize@24+0xc9>
   11e53:	52                   	push   %edx
   11e54:	6a 20                	push   $0x20
   11e56:	8b 50 14             	mov    0x14(%eax),%edx
   11e59:	52                   	push   %edx
   11e5a:	8b 40 08             	mov    0x8(%eax),%eax
   11e5d:	50                   	push   %eax
   11e5e:	ff 15 30 51 01 00    	call   *0x15130
   11e64:	eb c4                	jmp    11e2a <_MiniportInitialize@24+0x1ba>
   11e66:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11e69:	83 ec 0c             	sub    $0xc,%esp
   11e6c:	83 c0 1c             	add    $0x1c,%eax
   11e6f:	50                   	push   %eax
   11e70:	ff 15 2c 51 01 00    	call   *0x1512c
   11e76:	83 c4 0c             	add    $0xc,%esp
   11e79:	eb b5                	jmp    11e30 <_MiniportInitialize@24+0x1c0>
   11e7b:	83 ec 0c             	sub    $0xc,%esp
   11e7e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11e81:	50                   	push   %eax
   11e82:	e8 e9 f7 ff ff       	call   11670 <_MiPrepareInitializationBlock>
   11e87:	58                   	pop    %eax
   11e88:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11e8b:	50                   	push   %eax
   11e8c:	e8 1f fb ff ff       	call   119b0 <_MiInitChip>
   11e91:	58                   	pop    %eax
   11e92:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
   11e95:	57                   	push   %edi
   11e96:	ff 15 74 51 01 00    	call   *0x15174
   11e9c:	83 c4 0c             	add    $0xc,%esp
   11e9f:	e9 99 fe ff ff       	jmp    11d3d <_MiniportInitialize@24+0xcd>
   11ea4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11eaa:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011eb0 <_MiniportISR@12>:
   11eb0:	55                   	push   %ebp
   11eb1:	89 e5                	mov    %esp,%ebp
   11eb3:	57                   	push   %edi
   11eb4:	56                   	push   %esi
   11eb5:	53                   	push   %ebx
   11eb6:	83 ec 18             	sub    $0x18,%esp
   11eb9:	8b 5d 10             	mov    0x10(%ebp),%ebx
   11ebc:	8b 7d 08             	mov    0x8(%ebp),%edi
   11ebf:	8b 43 18             	mov    0x18(%ebx),%eax
   11ec2:	83 c0 12             	add    $0x12,%eax
   11ec5:	50                   	push   %eax
   11ec6:	ff 15 00 51 01 00    	call   *0x15100
   11ecc:	89 c6                	mov    %eax,%esi
   11ece:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11ed5:	8b 43 18             	mov    0x18(%ebx),%eax
   11ed8:	83 c0 12             	add    $0x12,%eax
   11edb:	50                   	push   %eax
   11edc:	ff 15 04 51 01 00    	call   *0x15104
   11ee2:	50                   	push   %eax
   11ee3:	8b 43 18             	mov    0x18(%ebx),%eax
   11ee6:	83 c0 10             	add    $0x10,%eax
   11ee9:	50                   	push   %eax
   11eea:	ff 15 00 51 01 00    	call   *0x15100
   11ef0:	83 c4 0c             	add    $0xc,%esp
   11ef3:	a9 80 00 00 00       	test   $0x80,%eax
   11ef8:	75 2a                	jne    11f24 <_MiniportISR@12+0x74>
   11efa:	c6 07 00             	movb   $0x0,(%edi)
   11efd:	8b 45 0c             	mov    0xc(%ebp),%eax
   11f00:	c6 00 00             	movb   $0x0,(%eax)
   11f03:	89 f0                	mov    %esi,%eax
   11f05:	25 ff ff 00 00       	and    $0xffff,%eax
   11f0a:	57                   	push   %edi
   11f0b:	57                   	push   %edi
   11f0c:	50                   	push   %eax
   11f0d:	8b 43 18             	mov    0x18(%ebx),%eax
   11f10:	83 c0 12             	add    $0x12,%eax
   11f13:	50                   	push   %eax
   11f14:	ff 15 04 51 01 00    	call   *0x15104
   11f1a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11f1d:	5b                   	pop    %ebx
   11f1e:	5e                   	pop    %esi
   11f1f:	5f                   	pop    %edi
   11f20:	5d                   	pop    %ebp
   11f21:	c2 0c 00             	ret    $0xc
   11f24:	51                   	push   %ecx
   11f25:	51                   	push   %ecx
   11f26:	6a 00                	push   $0x0
   11f28:	8b 43 18             	mov    0x18(%ebx),%eax
   11f2b:	83 c0 12             	add    $0x12,%eax
   11f2e:	50                   	push   %eax
   11f2f:	ff 15 04 51 01 00    	call   *0x15104
   11f35:	6a 00                	push   $0x0
   11f37:	8b 43 18             	mov    0x18(%ebx),%eax
   11f3a:	83 c0 10             	add    $0x10,%eax
   11f3d:	50                   	push   %eax
   11f3e:	ff 15 04 51 01 00    	call   *0x15104
   11f44:	c6 07 01             	movb   $0x1,(%edi)
   11f47:	8b 45 0c             	mov    0xc(%ebp),%eax
   11f4a:	c6 00 01             	movb   $0x1,(%eax)
   11f4d:	58                   	pop    %eax
   11f4e:	89 f0                	mov    %esi,%eax
   11f50:	5a                   	pop    %edx
   11f51:	25 ff ff 00 00       	and    $0xffff,%eax
   11f56:	57                   	push   %edi
   11f57:	57                   	push   %edi
   11f58:	50                   	push   %eax
   11f59:	8b 43 18             	mov    0x18(%ebx),%eax
   11f5c:	83 c0 12             	add    $0x12,%eax
   11f5f:	50                   	push   %eax
   11f60:	ff 15 04 51 01 00    	call   *0x15104
   11f66:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11f69:	5b                   	pop    %ebx
   11f6a:	5e                   	pop    %esi
   11f6b:	5f                   	pop    %edi
   11f6c:	5d                   	pop    %ebp
   11f6d:	c2 0c 00             	ret    $0xc

00011f70 <_MiniportReset@8>:
   11f70:	55                   	push   %ebp
   11f71:	89 e5                	mov    %esp,%ebp
   11f73:	8b 45 08             	mov    0x8(%ebp),%eax
   11f76:	c6 00 00             	movb   $0x0,(%eax)
   11f79:	31 c0                	xor    %eax,%eax
   11f7b:	5d                   	pop    %ebp
   11f7c:	c2 08 00             	ret    $0x8
   11f7f:	90                   	nop    

00011f80 <_MiSyncStartTransmit@4>:
   11f80:	55                   	push   %ebp
   11f81:	89 e5                	mov    %esp,%ebp
   11f83:	53                   	push   %ebx
   11f84:	83 ec 0c             	sub    $0xc,%esp
   11f87:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11f8a:	6a 00                	push   $0x0
   11f8c:	8b 43 18             	mov    0x18(%ebx),%eax
   11f8f:	83 c0 12             	add    $0x12,%eax
   11f92:	50                   	push   %eax
   11f93:	ff 15 04 51 01 00    	call   *0x15104
   11f99:	6a 48                	push   $0x48
   11f9b:	8b 43 18             	mov    0x18(%ebx),%eax
   11f9e:	83 c0 10             	add    $0x10,%eax
   11fa1:	50                   	push   %eax
   11fa2:	ff 15 04 51 01 00    	call   *0x15104
   11fa8:	b8 01 00 00 00       	mov    $0x1,%eax
   11fad:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11fb0:	c9                   	leave  
   11fb1:	c2 04 00             	ret    $0x4
   11fb4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11fba:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011fc0 <_MiniportSend@12>:
   11fc0:	55                   	push   %ebp
   11fc1:	89 e5                	mov    %esp,%ebp
   11fc3:	57                   	push   %edi
   11fc4:	56                   	push   %esi
   11fc5:	53                   	push   %ebx
   11fc6:	83 ec 1c             	sub    $0x1c,%esp
   11fc9:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   11fd0:	8b 7d 08             	mov    0x8(%ebp),%edi
   11fd3:	89 f9                	mov    %edi,%ecx
   11fd5:	ff 15 6c 51 01 00    	call   *0x1516c
   11fdb:	8b 97 d8 00 00 00    	mov    0xd8(%edi),%edx
   11fe1:	8b 8f d4 00 00 00    	mov    0xd4(%edi),%ecx
   11fe7:	8d 42 01             	lea    0x1(%edx),%eax
   11fea:	c6 47 04 02          	movb   $0x2,0x4(%edi)
   11fee:	39 c8                	cmp    %ecx,%eax
   11ff0:	0f 84 58 01 00 00    	je     1214e <_MiniportSend@12+0x18e>
   11ff6:	83 fa 1f             	cmp    $0x1f,%edx
   11ff9:	0f 84 47 01 00 00    	je     12146 <_MiniportSend@12+0x186>
   11fff:	8b 87 d8 00 00 00    	mov    0xd8(%edi),%eax
   12005:	8b 97 ec 00 00 00    	mov    0xec(%edi),%edx
   1200b:	c1 e0 04             	shl    $0x4,%eax
   1200e:	01 d0                	add    %edx,%eax
   12010:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12013:	8b 45 0c             	mov    0xc(%ebp),%eax
   12016:	8b 70 08             	mov    0x8(%eax),%esi
   12019:	80 78 1c 00          	cmpb   $0x0,0x1c(%eax)
   1201d:	74 69                	je     12088 <_MiniportSend@12+0xc8>
   1201f:	8b 55 0c             	mov    0xc(%ebp),%edx
   12022:	8b 52 04             	mov    0x4(%edx),%edx
   12025:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
   12028:	eb 3d                	jmp    12067 <_MiniportSend@12+0xa7>
   1202a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12030:	8b 56 0c             	mov    0xc(%esi),%edx
   12033:	8b 87 d8 00 00 00    	mov    0xd8(%edi),%eax
   12039:	8b 8f f8 00 00 00    	mov    0xf8(%edi),%ecx
   1203f:	8b 5e 14             	mov    0x14(%esi),%ebx
   12042:	8d 04 40             	lea    (%eax,%eax,2),%eax
   12045:	c1 e0 09             	shl    $0x9,%eax
   12048:	01 c8                	add    %ecx,%eax
   1204a:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   1204d:	01 c8                	add    %ecx,%eax
   1204f:	51                   	push   %ecx
   12050:	53                   	push   %ebx
   12051:	52                   	push   %edx
   12052:	50                   	push   %eax
   12053:	e8 c8 09 00 00       	call   12a20 <_memcpy>
   12058:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1205b:	01 d8                	add    %ebx,%eax
   1205d:	83 c4 10             	add    $0x10,%esp
   12060:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   12063:	8b 06                	mov    (%esi),%eax
   12065:	89 c6                	mov    %eax,%esi
   12067:	85 f6                	test   %esi,%esi
   12069:	0f 84 87 00 00 00    	je     120f6 <_MiniportSend@12+0x136>
   1206f:	0f bf 46 06          	movswl 0x6(%esi),%eax
   12073:	a8 05                	test   $0x5,%al
   12075:	75 b9                	jne    12030 <_MiniportSend@12+0x70>
   12077:	51                   	push   %ecx
   12078:	51                   	push   %ecx
   12079:	6a 00                	push   $0x0
   1207b:	56                   	push   %esi
   1207c:	ff 15 78 51 01 00    	call   *0x15178
   12082:	5b                   	pop    %ebx
   12083:	5a                   	pop    %edx
   12084:	89 c2                	mov    %eax,%edx
   12086:	eb ab                	jmp    12033 <_MiniportSend@12+0x73>
   12088:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   1208f:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   12096:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   1209d:	89 f3                	mov    %esi,%ebx
   1209f:	85 f6                	test   %esi,%esi
   120a1:	74 2d                	je     120d0 <_MiniportSend@12+0x110>
   120a3:	83 ec 0c             	sub    $0xc,%esp
   120a6:	53                   	push   %ebx
   120a7:	ff 15 10 51 01 00    	call   *0x15110
   120ad:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   120b0:	83 c4 0c             	add    $0xc,%esp
   120b3:	01 c2                	add    %eax,%edx
   120b5:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   120b8:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
   120bb:	8b 53 14             	mov    0x14(%ebx),%edx
   120be:	01 d0                	add    %edx,%eax
   120c0:	8b 1b                	mov    (%ebx),%ebx
   120c2:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   120c5:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   120c8:	40                   	inc    %eax
   120c9:	85 db                	test   %ebx,%ebx
   120cb:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   120ce:	75 d3                	jne    120a3 <_MiniportSend@12+0xe3>
   120d0:	8b 45 0c             	mov    0xc(%ebp),%eax
   120d3:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   120d6:	85 f6                	test   %esi,%esi
   120d8:	89 10                	mov    %edx,(%eax)
   120da:	8b 55 0c             	mov    0xc(%ebp),%edx
   120dd:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   120e0:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   120e3:	89 42 04             	mov    %eax,0x4(%edx)
   120e6:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   120e9:	c6 42 1c 01          	movb   $0x1,0x1c(%edx)
   120ed:	89 42 14             	mov    %eax,0x14(%edx)
   120f0:	0f 85 79 ff ff ff    	jne    1206f <_MiniportSend@12+0xaf>
   120f6:	8b 87 d8 00 00 00    	mov    0xd8(%edi),%eax
   120fc:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   120ff:	40                   	inc    %eax
   12100:	83 e0 1f             	and    $0x1f,%eax
   12103:	89 87 d8 00 00 00    	mov    %eax,0xd8(%edi)
   12109:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1210c:	66 c7 40 06 00 83    	movw   $0x8300,0x6(%eax)
   12112:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12115:	f7 d8                	neg    %eax
   12117:	0d 00 f0 ff ff       	or     $0xfffff000,%eax
   1211c:	66 89 42 04          	mov    %ax,0x4(%edx)
   12120:	50                   	push   %eax
   12121:	8d 47 1c             	lea    0x1c(%edi),%eax
   12124:	57                   	push   %edi
   12125:	68 80 1f 01 00       	push   $0x11f80
   1212a:	50                   	push   %eax
   1212b:	ff 15 54 51 01 00    	call   *0x15154
   12131:	89 f9                	mov    %edi,%ecx
   12133:	58                   	pop    %eax
   12134:	ff 15 70 51 01 00    	call   *0x15170
   1213a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1213d:	31 c0                	xor    %eax,%eax
   1213f:	5b                   	pop    %ebx
   12140:	5e                   	pop    %esi
   12141:	5f                   	pop    %edi
   12142:	5d                   	pop    %ebp
   12143:	c2 0c 00             	ret    $0xc
   12146:	85 c9                	test   %ecx,%ecx
   12148:	0f 85 b1 fe ff ff    	jne    11fff <_MiniportSend@12+0x3f>
   1214e:	89 f9                	mov    %edi,%ecx
   12150:	ff 15 70 51 01 00    	call   *0x15170
   12156:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12159:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   1215e:	5b                   	pop    %ebx
   1215f:	5e                   	pop    %esi
   12160:	5f                   	pop    %edi
   12161:	5d                   	pop    %ebp
   12162:	c2 0c 00             	ret    $0xc
   12165:	8d 74 26 00          	lea    0x0(%esi),%esi
   12169:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012170 <_MiEthernetCrc@4>:
   12170:	55                   	push   %ebp
   12171:	89 e5                	mov    %esp,%ebp
   12173:	57                   	push   %edi
   12174:	56                   	push   %esi
   12175:	53                   	push   %ebx
   12176:	57                   	push   %edi
   12177:	8b 7d 08             	mov    0x8(%ebp),%edi
   1217a:	83 cb ff             	or     $0xffffffff,%ebx
   1217d:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   12184:	31 c0                	xor    %eax,%eax
   12186:	be 07 00 00 00       	mov    $0x7,%esi
   1218b:	8a 07                	mov    (%edi),%al
   1218d:	47                   	inc    %edi
   1218e:	31 c3                	xor    %eax,%ebx
   12190:	d1 eb                	shr    %ebx
   12192:	89 d8                	mov    %ebx,%eax
   12194:	83 e0 01             	and    $0x1,%eax
   12197:	8d 14 00             	lea    (%eax,%eax,1),%edx
   1219a:	01 c2                	add    %eax,%edx
   1219c:	c1 e2 04             	shl    $0x4,%edx
   1219f:	29 c2                	sub    %eax,%edx
   121a1:	8d 14 d2             	lea    (%edx,%edx,8),%edx
   121a4:	8d 14 d2             	lea    (%edx,%edx,8),%edx
   121a7:	8d 14 90             	lea    (%eax,%edx,4),%edx
   121aa:	89 d1                	mov    %edx,%ecx
   121ac:	c1 e1 0a             	shl    $0xa,%ecx
   121af:	29 d1                	sub    %edx,%ecx
   121b1:	8d 0c c8             	lea    (%eax,%ecx,8),%ecx
   121b4:	c1 e1 05             	shl    $0x5,%ecx
   121b7:	31 cb                	xor    %ecx,%ebx
   121b9:	4e                   	dec    %esi
   121ba:	79 d4                	jns    12190 <_MiEthernetCrc@4+0x20>
   121bc:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   121bf:	46                   	inc    %esi
   121c0:	89 75 f0             	mov    %esi,0xfffffff0(%ebp)
   121c3:	83 7d f0 05          	cmpl   $0x5,0xfffffff0(%ebp)
   121c7:	76 bb                	jbe    12184 <_MiEthernetCrc@4+0x14>
   121c9:	89 d8                	mov    %ebx,%eax
   121cb:	59                   	pop    %ecx
   121cc:	5b                   	pop    %ebx
   121cd:	5e                   	pop    %esi
   121ce:	5f                   	pop    %edi
   121cf:	5d                   	pop    %ebp
   121d0:	c2 04 00             	ret    $0x4
   121d3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   121d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000121e0 <_MiSetMulticast@12>:
   121e0:	55                   	push   %ebp
   121e1:	89 e5                	mov    %esp,%ebp
   121e3:	57                   	push   %edi
   121e4:	56                   	push   %esi
   121e5:	53                   	push   %ebx
   121e6:	8b 4d 08             	mov    0x8(%ebp),%ecx
   121e9:	8b 55 10             	mov    0x10(%ebp),%edx
   121ec:	8b 75 0c             	mov    0xc(%ebp),%esi
   121ef:	85 d2                	test   %edx,%edx
   121f1:	8b 81 e0 00 00 00    	mov    0xe0(%ecx),%eax
   121f7:	c7 40 0c 00 00 00 00 	movl   $0x0,0xc(%eax)
   121fe:	c7 40 10 00 00 00 00 	movl   $0x0,0x10(%eax)
   12205:	74 36                	je     1223d <_MiSetMulticast@12+0x5d>
   12207:	89 d3                	mov    %edx,%ebx
   12209:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12210:	56                   	push   %esi
   12211:	e8 5a ff ff ff       	call   12170 <_MiEthernetCrc@4>
   12216:	8b 7d 08             	mov    0x8(%ebp),%edi
   12219:	89 c1                	mov    %eax,%ecx
   1221b:	c1 e9 1a             	shr    $0x1a,%ecx
   1221e:	83 c6 06             	add    $0x6,%esi
   12221:	83 e1 0f             	and    $0xf,%ecx
   12224:	8b 97 e0 00 00 00    	mov    0xe0(%edi),%edx
   1222a:	c1 e8 1d             	shr    $0x1d,%eax
   1222d:	bf 01 00 00 00       	mov    $0x1,%edi
   12232:	d3 e7                	shl    %cl,%edi
   12234:	89 f9                	mov    %edi,%ecx
   12236:	08 4c 10 0c          	or     %cl,0xc(%eax,%edx,1)
   1223a:	4b                   	dec    %ebx
   1223b:	75 d3                	jne    12210 <_MiSetMulticast@12+0x30>
   1223d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12240:	31 c0                	xor    %eax,%eax
   12242:	5b                   	pop    %ebx
   12243:	5e                   	pop    %esi
   12244:	5f                   	pop    %edi
   12245:	5d                   	pop    %ebp
   12246:	c2 0c 00             	ret    $0xc
   12249:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012250 <_DriverEntry@8>:

NTSTATUS
STDCALL
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath)
/*
 * FUNCTION: Start this driver
 * ARGUMENTS:
 *     DriverObject: Pointer to the system-allocated driver object
 *     RegistryPath: Pointer to our SCM database entry
 * RETURNS:
 *     NDIS_STATUS_SUCCESS on success
 *     NDIS_STATUS_FAILURE on failure
 * NOTES:
 *     - Called by the I/O manager when the driver starts at PASSIVE_LEVEL
 *     - TODO: convert this to NTSTATUS return values
 */
{
   12250:	55                   	push   %ebp
   12251:	89 e5                	mov    %esp,%ebp
   12253:	53                   	push   %ebx
   12254:	83 ec 78             	sub    $0x78,%esp
  NDIS_HANDLE WrapperHandle;
  NDIS_MINIPORT_CHARACTERISTICS Characteristics;
  NDIS_STATUS Status;

  RtlZeroMemory(&Characteristics, sizeof(Characteristics));
   12257:	8d 5d 98             	lea    0xffffff98(%ebp),%ebx
   1225a:	6a 60                	push   $0x60
   1225c:	6a 00                	push   $0x0
   1225e:	53                   	push   %ebx
   1225f:	e8 cc 07 00 00       	call   12a30 <_memset>
  Characteristics.MajorNdisVersion = NDIS_MINIPORT_MAJOR_VERSION;
  Characteristics.MinorNdisVersion = NDIS_MINIPORT_MINOR_VERSION;
  Characteristics.HaltHandler = MiniportHalt;
  Characteristics.HandleInterruptHandler = MiniportHandleInterrupt;
  Characteristics.InitializeHandler = MiniportInitialize;
  Characteristics.ISRHandler = MiniportISR;
  Characteristics.QueryInformationHandler = MiniportQueryInformation;
  Characteristics.ResetHandler = MiniportReset;
  Characteristics.SetInformationHandler = MiniportSetInformation;
  Characteristics.SendHandler = MiniportSend;

  NdisMInitializeWrapper(&WrapperHandle, DriverObject, RegistryPath, 0);
   12264:	8b 45 0c             	mov    0xc(%ebp),%eax
   12267:	6a 00                	push   $0x0
   12269:	50                   	push   %eax
   1226a:	8b 45 08             	mov    0x8(%ebp),%eax
   1226d:	50                   	push   %eax
   1226e:	c6 45 98 05          	movb   $0x5,0xffffff98(%ebp)
   12272:	8d 45 94             	lea    0xffffff94(%ebp),%eax
   12275:	c6 45 99 00          	movb   $0x0,0xffffff99(%ebp)
   12279:	c7 45 ac 60 18 01 00 	movl   $0x11860,0xffffffac(%ebp)
   12280:	c7 45 b0 00 10 01 00 	movl   $0x11000,0xffffffb0(%ebp)
   12287:	c7 45 b4 70 1c 01 00 	movl   $0x11c70,0xffffffb4(%ebp)
   1228e:	c7 45 b8 b0 1e 01 00 	movl   $0x11eb0,0xffffffb8(%ebp)
   12295:	c7 45 bc f0 22 01 00 	movl   $0x122f0,0xffffffbc(%ebp)
   1229c:	c7 45 c4 70 1f 01 00 	movl   $0x11f70,0xffffffc4(%ebp)
   122a3:	c7 45 cc 00 27 01 00 	movl   $0x12700,0xffffffcc(%ebp)
   122aa:	c7 45 c8 c0 1f 01 00 	movl   $0x11fc0,0xffffffc8(%ebp)
   122b1:	50                   	push   %eax
   122b2:	ff 15 1c 51 01 00    	call   *0x1511c

  Status = NdisMRegisterMiniport(WrapperHandle, &Characteristics, sizeof(Characteristics));
   122b8:	83 c4 0c             	add    $0xc,%esp
   122bb:	8b 4d 94             	mov    0xffffff94(%ebp),%ecx
   122be:	6a 60                	push   $0x60
   122c0:	53                   	push   %ebx
   122c1:	51                   	push   %ecx
   122c2:	ff 15 48 51 01 00    	call   *0x15148
  if(Status != NDIS_STATUS_SUCCESS)
   122c8:	5a                   	pop    %edx
    {
      NdisTerminateWrapper(WrapperHandle, 0);
      return NDIS_STATUS_FAILURE;
    }

  return NDIS_STATUS_SUCCESS;
   122c9:	31 d2                	xor    %edx,%edx
   122cb:	85 c0                	test   %eax,%eax
   122cd:	75 09                	jne    122d8 <_DriverEntry@8+0x88>
}
   122cf:	89 d0                	mov    %edx,%eax
   122d1:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   122d4:	c9                   	leave  
   122d5:	c2 08 00             	ret    $0x8
   122d8:	50                   	push   %eax
   122d9:	50                   	push   %eax
   122da:	8b 45 94             	mov    0xffffff94(%ebp),%eax
   122dd:	6a 00                	push   $0x0
   122df:	50                   	push   %eax
   122e0:	ff 15 5c 51 01 00    	call   *0x1515c
   122e6:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   122eb:	eb e2                	jmp    122cf <_DriverEntry@8+0x7f>
   122ed:	90                   	nop    
   122ee:	90                   	nop    
   122ef:	90                   	nop    

000122f0 <_MiniportQueryInformation@24>:
 *       needed in BytesNeeded and return NDIS_STATUS_INVALID_LENGTH
 * TODO:
 *     - Update to verify input buffer & size and return insufficient buffer codes
 */
{
   122f0:	55                   	push   %ebp
   122f1:	89 e5                	mov    %esp,%ebp
   122f3:	57                   	push   %edi
   122f4:	56                   	push   %esi
   122f5:	53                   	push   %ebx
   122f6:	83 ec 14             	sub    $0x14,%esp
  NDIS_STATUS Status;
  PVOID CopyFrom;
  UINT CopySize;
  ULONG GenericULONG;
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;

  PCNET_DbgPrint(("Called. OID 0x%x\n", Oid));

  ASSERT(Adapter);

  NdisAcquireSpinLock(&Adapter->Lock);

  Status   = NDIS_STATUS_SUCCESS;
  CopyFrom = (PVOID)&GenericULONG;
  CopySize = sizeof(ULONG);
   122f9:	bf 04 00 00 00       	mov    $0x4,%edi
   122fe:	8b 75 08             	mov    0x8(%ebp),%esi
   12301:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   12304:	8d 46 04             	lea    0x4(%esi),%eax
   12307:	50                   	push   %eax
   12308:	56                   	push   %esi
   12309:	ff 15 f0 50 01 00    	call   *0x150f0
   1230f:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   12312:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   12319:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)

  switch (Oid) 
   1231c:	58                   	pop    %eax
   1231d:	81 fb 11 01 01 00    	cmp    $0x10111,%ebx
   12323:	5a                   	pop    %edx
   12324:	0f 84 c6 00 00 00    	je     123f0 <_MiniportQueryInformation@24+0x100>
   1232a:	77 58                	ja     12384 <_MiniportQueryInformation@24+0x94>
   1232c:	81 fb 08 01 01 00    	cmp    $0x10108,%ebx
   12332:	0f 84 b8 01 00 00    	je     124f0 <_MiniportQueryInformation@24+0x200>
   12338:	0f 86 32 01 00 00    	jbe    12470 <_MiniportQueryInformation@24+0x180>
   1233e:	81 fb 0c 01 01 00    	cmp    $0x1010c,%ebx
   12344:	0f 84 c6 02 00 00    	je     12610 <_MiniportQueryInformation@24+0x320>
   1234a:	0f 86 a0 01 00 00    	jbe    124f0 <_MiniportQueryInformation@24+0x200>
   12350:	81 fb 0e 01 01 00    	cmp    $0x1010e,%ebx
   12356:	0f 84 57 02 00 00    	je     125b3 <_MiniportQueryInformation@24+0x2c3>
   1235c:	0f 82 9d 02 00 00    	jb     125ff <_MiniportQueryInformation@24+0x30f>
   12362:	81 fb 0f 01 01 00    	cmp    $0x1010f,%ebx
   12368:	0f 84 c6 01 00 00    	je     12534 <_MiniportQueryInformation@24+0x244>
   1236e:	81 fb 10 01 01 00    	cmp    $0x10110,%ebx
   12374:	75 50                	jne    123c6 <_MiniportQueryInformation@24+0xd6>
    {
    case OID_GEN_SUPPORTED_LIST:
        {
          CopyFrom = (PVOID)&MiniportOIDList;
          CopySize = sizeof(MiniportOIDList);
          break;
        }

    case OID_GEN_HARDWARE_STATUS:
        {
          /* TODO: implement this... */
          GenericULONG = (ULONG)NdisHardwareStatusReady;
          break;
        }

    case OID_GEN_MEDIA_SUPPORTED:
    case OID_GEN_MEDIA_IN_USE:
        {
          static const NDIS_MEDIUM Medium = NdisMedium802_3;
          CopyFrom = (PVOID)&Medium;
          CopySize = sizeof(NDIS_MEDIUM);
          break;
        }

    case OID_GEN_CURRENT_LOOKAHEAD:
    case OID_GEN_MAXIMUM_LOOKAHEAD:
        {
          GenericULONG = 1500;
          break;
        }

    case OID_GEN_MAXIMUM_FRAME_SIZE:
        {
          /*
           * The value returned by this OID must be equal to
           * OID_GEN_MAXIMUM_TOTAL_SIZE - sizeof(ETHERNET_HEADER)
           * where sizeof(ETHERNET_HEADER) is 14.
           */
          GenericULONG = 1500;
          break;
        }

    case OID_GEN_LINK_SPEED:
        {     
          GenericULONG = 100000;  /* 10Mbps */
          break;
        }

    case OID_GEN_TRANSMIT_BUFFER_SPACE:
        {
          /* XXX fix me */
          GenericULONG = BUFFER_SIZE;
          break;
        }

    case OID_GEN_RECEIVE_BUFFER_SPACE:
        {
          /* XXX fix me */
          GenericULONG = BUFFER_SIZE;
          break;
        }

    case OID_GEN_TRANSMIT_BLOCK_SIZE:
        {
          GenericULONG = BUFFER_SIZE;
          break;
        }

    case OID_GEN_RECEIVE_BLOCK_SIZE:
        {
          GenericULONG = BUFFER_SIZE;
          break;
        }

    case OID_GEN_VENDOR_ID:
        {
          UCHAR *CharPtr = (UCHAR *)&GenericULONG;
          GenericULONG = 0;
          /* Read the first three bytes of the permanent MAC address */
          NdisRawReadPortUchar(Adapter->PortOffset, CharPtr);
          NdisRawReadPortUchar(Adapter->PortOffset + 1, CharPtr + 1);
          NdisRawReadPortUchar(Adapter->PortOffset + 2, CharPtr + 2);
          break;
        }

    case OID_GEN_VENDOR_DESCRIPTION:
        {
          static UCHAR VendorDesc[] = "ReactOS Team";
          CopyFrom = VendorDesc;
          CopySize = sizeof(VendorDesc);
          break;
        }

    case OID_GEN_VENDOR_DRIVER_VERSION:
        {
          /* XXX implement me */
          GenericULONG = 1;
          break;
        }

    case OID_GEN_CURRENT_PACKET_FILTER:
        {
          GenericULONG = Adapter->CurrentPacketFilter;
          break;
        }

    case OID_GEN_DRIVER_VERSION:
        {
          /* NDIS version used by the driver. */
          static const USHORT DriverVersion =
            (NDIS_MINIPORT_MAJOR_VERSION << 8) + NDIS_MINIPORT_MINOR_VERSION;
          CopyFrom = (PVOID)&DriverVersion;
          CopySize = sizeof(DriverVersion);
   12376:	bf 02 00 00 00       	mov    $0x2,%edi
   1237b:	c7 45 e8 04 40 01 00 	movl   $0x14004,0xffffffe8(%ebp)
   12382:	eb 73                	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12384:	81 fb 04 01 02 00    	cmp    $0x20104,%ebx
   1238a:	0f 84 70 01 00 00    	je     12500 <_MiniportQueryInformation@24+0x210>
   12390:	0f 87 1a 01 00 00    	ja     124b0 <_MiniportQueryInformation@24+0x1c0>
   12396:	81 fb 15 01 01 00    	cmp    $0x10115,%ebx
   1239c:	0f 84 1f 02 00 00    	je     125c1 <_MiniportQueryInformation@24+0x2d1>
   123a2:	0f 86 be 01 00 00    	jbe    12566 <_MiniportQueryInformation@24+0x276>
   123a8:	81 fb 01 01 02 00    	cmp    $0x20101,%ebx
   123ae:	0f 84 ec 02 00 00    	je     126a0 <_MiniportQueryInformation@24+0x3b0>
   123b4:	0f 87 93 02 00 00    	ja     1264d <_MiniportQueryInformation@24+0x35d>
   123ba:	81 fb 16 01 01 00    	cmp    $0x10116,%ebx
   123c0:	0f 84 fb 01 00 00    	je     125c1 <_MiniportQueryInformation@24+0x2d1>
          break;
        }

    case OID_GEN_MAXIMUM_TOTAL_SIZE:
        {
          /* See comment in OID_GEN_MAXIMUM_FRAME_SIZE. */
          GenericULONG = 1514;
          break;
        }

    case OID_GEN_PROTOCOL_OPTIONS:
        {
          PCNET_DbgPrint(("OID_GEN_PROTOCOL_OPTIONS.\n"));
          Status = NDIS_STATUS_NOT_SUPPORTED;
          break;
        }

    case OID_GEN_MAC_OPTIONS:
        {
          GenericULONG = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                         NDIS_MAC_OPTION_RECEIVE_SERIALIZED  |           
                         NDIS_MAC_OPTION_TRANSFERS_NOT_PEND;
          break;
        }

    case OID_GEN_MEDIA_CONNECT_STATUS:
        {
          GenericULONG = Adapter->MediaState;
          break;
        }

    case OID_GEN_MAXIMUM_SEND_PACKETS:
        {
          GenericULONG = 1;
          break;
        }

    case OID_802_3_CURRENT_ADDRESS:
    case OID_802_3_PERMANENT_ADDRESS:
        {
          CopyFrom = (PVOID)&Adapter->InitializationBlockVirt->PADR;
          CopySize = 6;
          break;
        }

    case OID_802_3_MAXIMUM_LIST_SIZE:
        {
          GenericULONG = MAX_MULTICAST_ADDRESSES;
          break;
        }

    case OID_GEN_XMIT_OK:
        GenericULONG = Adapter->Statistics.XmtGoodFrames;
        break;

    case OID_GEN_RCV_OK:
        GenericULONG = Adapter->Statistics.RcvGoodFrames;
        break;

    case OID_GEN_XMIT_ERROR:
        GenericULONG = Adapter->Statistics.XmtRetryErrors +
                       Adapter->Statistics.XmtLossesOfCarrier +
                       Adapter->Statistics.XmtCollisions +
                       Adapter->Statistics.XmtLateCollisions +
                       Adapter->Statistics.XmtExcessiveDefferals +
                       Adapter->Statistics.XmtBufferUnderflows +
                       Adapter->Statistics.XmtBufferErrors;
        break;

    case OID_GEN_RCV_ERROR:
        GenericULONG = Adapter->Statistics.RcvBufferErrors +
                       Adapter->Statistics.RcvCrcErrors +
                       Adapter->Statistics.RcvOverflowErrors +
                       Adapter->Statistics.RcvFramingErrors;
        break;

    case OID_GEN_RCV_NO_BUFFER:
        GenericULONG = Adapter->Statistics.RcvBufferErrors + 
                       Adapter->Statistics.RcvOverflowErrors;
        break;

    case OID_GEN_RCV_CRC_ERROR:
        GenericULONG = Adapter->Statistics.RcvCrcErrors;
        break;

    case OID_802_3_RCV_ERROR_ALIGNMENT:
        GenericULONG = Adapter->Statistics.RcvFramingErrors;
        break;

    case OID_802_3_XMIT_ONE_COLLISION:
        GenericULONG = Adapter->Statistics.XmtOneRetry;
        break;

    case OID_802_3_XMIT_MORE_COLLISIONS:
        GenericULONG = Adapter->Statistics.XmtMoreThanOneRetry;
        break;

    default:
        {
          PCNET_DbgPrint(("Unknown OID\n"));
          Status = NDIS_STATUS_NOT_SUPPORTED;
   123c6:	c7 45 ec bb 00 00 c0 	movl   $0xc00000bb,0xffffffec(%ebp)
          break;
        }
    }

  if (Status == NDIS_STATUS_SUCCESS) 
    {
      if (CopySize > InformationBufferLength) 
        {
          *BytesNeeded  = (CopySize - InformationBufferLength);
          *BytesWritten = 0;
          Status        = NDIS_STATUS_BUFFER_TOO_SHORT;
        } 
      else 
        {
          NdisMoveMemory(InformationBuffer, CopyFrom, CopySize);
          *BytesWritten = CopySize;
          *BytesNeeded  = CopySize;
         }
    }

  NdisReleaseSpinLock(&Adapter->Lock);
   123cd:	50                   	push   %eax
   123ce:	50                   	push   %eax
   123cf:	31 c0                	xor    %eax,%eax
   123d1:	8a 46 04             	mov    0x4(%esi),%al
   123d4:	50                   	push   %eax
   123d5:	56                   	push   %esi
   123d6:	ff 15 f4 50 01 00    	call   *0x150f4

  PCNET_DbgPrint(("Leaving. Status is 0x%x\n", Status));

  return Status;
}
   123dc:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   123df:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   123e2:	5b                   	pop    %ebx
   123e3:	5e                   	pop    %esi
   123e4:	5f                   	pop    %edi
   123e5:	5d                   	pop    %ebp
   123e6:	c2 18 00             	ret    $0x18
   123e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   123f0:	c7 45 f0 ea 05 00 00 	movl   $0x5ea,0xfffffff0(%ebp)
   123f7:	3b 7d 14             	cmp    0x14(%ebp),%edi
   123fa:	76 36                	jbe    12432 <_MiniportQueryInformation@24+0x142>
   123fc:	8b 45 14             	mov    0x14(%ebp),%eax
   123ff:	c7 45 ec 16 00 01 c0 	movl   $0xc0010016,0xffffffec(%ebp)
   12406:	29 c7                	sub    %eax,%edi
   12408:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1240b:	89 38                	mov    %edi,(%eax)
   1240d:	8b 45 18             	mov    0x18(%ebp),%eax
   12410:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12416:	50                   	push   %eax
   12417:	50                   	push   %eax
   12418:	31 c0                	xor    %eax,%eax
   1241a:	8a 46 04             	mov    0x4(%esi),%al
   1241d:	50                   	push   %eax
   1241e:	56                   	push   %esi
   1241f:	ff 15 f4 50 01 00    	call   *0x150f4
   12425:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12428:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1242b:	5b                   	pop    %ebx
   1242c:	5e                   	pop    %esi
   1242d:	5f                   	pop    %edi
   1242e:	5d                   	pop    %ebp
   1242f:	c2 18 00             	ret    $0x18
   12432:	53                   	push   %ebx
   12433:	57                   	push   %edi
   12434:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   12437:	51                   	push   %ecx
   12438:	8b 55 10             	mov    0x10(%ebp),%edx
   1243b:	52                   	push   %edx
   1243c:	e8 df 05 00 00       	call   12a20 <_memcpy>
   12441:	8b 45 18             	mov    0x18(%ebp),%eax
   12444:	83 c4 10             	add    $0x10,%esp
   12447:	89 38                	mov    %edi,(%eax)
   12449:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1244c:	89 38                	mov    %edi,(%eax)
   1244e:	50                   	push   %eax
   1244f:	50                   	push   %eax
   12450:	31 c0                	xor    %eax,%eax
   12452:	8a 46 04             	mov    0x4(%esi),%al
   12455:	50                   	push   %eax
   12456:	56                   	push   %esi
   12457:	ff 15 f4 50 01 00    	call   *0x150f4
   1245d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12460:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12463:	5b                   	pop    %ebx
   12464:	5e                   	pop    %esi
   12465:	5f                   	pop    %edi
   12466:	5d                   	pop    %ebp
   12467:	c2 18 00             	ret    $0x18
   1246a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12470:	81 fb 04 01 01 00    	cmp    $0x10104,%ebx
   12476:	0f 87 aa 00 00 00    	ja     12526 <_MiniportQueryInformation@24+0x236>
   1247c:	81 fb 03 01 01 00    	cmp    $0x10103,%ebx
   12482:	0f 83 11 01 00 00    	jae    12599 <_MiniportQueryInformation@24+0x2a9>
   12488:	81 fb 01 01 01 00    	cmp    $0x10101,%ebx
   1248e:	0f 84 26 02 00 00    	je     126ba <_MiniportQueryInformation@24+0x3ca>
   12494:	81 fb 02 01 01 00    	cmp    $0x10102,%ebx
   1249a:	0f 85 26 ff ff ff    	jne    123c6 <_MiniportQueryInformation@24+0xd6>
   124a0:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   124a7:	e9 4b ff ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   124ac:	8d 74 26 00          	lea    0x0(%esi),%esi
   124b0:	81 fb 02 01 01 01    	cmp    $0x1010102,%ebx
   124b6:	0f 87 84 00 00 00    	ja     12540 <_MiniportQueryInformation@24+0x250>
   124bc:	81 fb 01 01 01 01    	cmp    $0x1010101,%ebx
   124c2:	0f 83 bb 00 00 00    	jae    12583 <_MiniportQueryInformation@24+0x293>
   124c8:	81 fb 05 01 02 00    	cmp    $0x20105,%ebx
   124ce:	0f 84 f7 01 00 00    	je     126cb <_MiniportQueryInformation@24+0x3db>
   124d4:	81 fb 0d 02 02 00    	cmp    $0x2020d,%ebx
   124da:	0f 85 e6 fe ff ff    	jne    123c6 <_MiniportQueryInformation@24+0xd6>
   124e0:	8b 86 48 01 00 00    	mov    0x148(%esi),%eax
   124e6:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   124e9:	e9 09 ff ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   124ee:	89 f6                	mov    %esi,%esi
   124f0:	c7 45 f0 00 06 00 00 	movl   $0x600,0xfffffff0(%ebp)
   124f7:	e9 fb fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   124fc:	8d 74 26 00          	lea    0x0(%esi),%esi
   12500:	8b 86 48 01 00 00    	mov    0x148(%esi),%eax
   12506:	8b 96 44 01 00 00    	mov    0x144(%esi),%edx
   1250c:	01 d0                	add    %edx,%eax
   1250e:	8b 9e 4c 01 00 00    	mov    0x14c(%esi),%ebx
   12514:	01 d8                	add    %ebx,%eax
   12516:	8b 8e 50 01 00 00    	mov    0x150(%esi),%ecx
   1251c:	01 c8                	add    %ecx,%eax
   1251e:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12521:	e9 d1 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12526:	81 fb 06 01 01 00    	cmp    $0x10106,%ebx
   1252c:	74 06                	je     12534 <_MiniportQueryInformation@24+0x244>
   1252e:	0f 87 99 00 00 00    	ja     125cd <_MiniportQueryInformation@24+0x2dd>
   12534:	c7 45 f0 dc 05 00 00 	movl   $0x5dc,0xfffffff0(%ebp)
   1253b:	e9 b7 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12540:	81 fb 01 01 02 01    	cmp    $0x1020101,%ebx
   12546:	74 5d                	je     125a5 <_MiniportQueryInformation@24+0x2b5>
   12548:	0f 87 8b 00 00 00    	ja     125d9 <_MiniportQueryInformation@24+0x2e9>
   1254e:	81 fb 04 01 01 01    	cmp    $0x1010104,%ebx
   12554:	0f 85 6c fe ff ff    	jne    123c6 <_MiniportQueryInformation@24+0xd6>
   1255a:	c7 45 f0 20 00 00 00 	movl   $0x20,0xfffffff0(%ebp)
   12561:	e9 91 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12566:	81 fb 13 01 01 00    	cmp    $0x10113,%ebx
   1256c:	0f 84 3c 01 00 00    	je     126ae <_MiniportQueryInformation@24+0x3be>
   12572:	0f 86 4e fe ff ff    	jbe    123c6 <_MiniportQueryInformation@24+0xd6>
   12578:	8b 46 6c             	mov    0x6c(%esi),%eax
   1257b:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1257e:	e9 74 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12583:	8b 86 e0 00 00 00    	mov    0xe0(%esi),%eax
   12589:	bf 06 00 00 00       	mov    $0x6,%edi
   1258e:	83 c0 04             	add    $0x4,%eax
   12591:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12594:	e9 5e fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12599:	c7 45 e8 00 40 01 00 	movl   $0x14000,0xffffffe8(%ebp)
   125a0:	e9 52 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   125a5:	8b 86 50 01 00 00    	mov    0x150(%esi),%eax
   125ab:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   125ae:	e9 44 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   125b3:	8b 86 cc 00 00 00    	mov    0xcc(%esi),%eax
   125b9:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   125bc:	e9 36 fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   125c1:	c7 45 f0 01 00 00 00 	movl   $0x1,0xfffffff0(%ebp)
   125c8:	e9 2a fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   125cd:	c7 45 f0 a0 86 01 00 	movl   $0x186a0,0xfffffff0(%ebp)
   125d4:	e9 1e fe ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   125d9:	81 fb 02 01 02 01    	cmp    $0x1020102,%ebx
   125df:	0f 84 fc 00 00 00    	je     126e1 <_MiniportQueryInformation@24+0x3f1>
   125e5:	81 fb 03 01 02 01    	cmp    $0x1020103,%ebx
   125eb:	0f 85 d5 fd ff ff    	jne    123c6 <_MiniportQueryInformation@24+0xd6>
   125f1:	8b 86 3c 01 00 00    	mov    0x13c(%esi),%eax
   125f7:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   125fa:	e9 f8 fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   125ff:	bf 0d 00 00 00       	mov    $0xd,%edi
   12604:	c7 45 e8 90 30 01 00 	movl   $0x13090,0xffffffe8(%ebp)
   1260b:	e9 e7 fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   12610:	83 ec 0c             	sub    $0xc,%esp
   12613:	8b 4e 18             	mov    0x18(%esi),%ecx
   12616:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   1261d:	51                   	push   %ecx
   1261e:	ff 15 fc 50 01 00    	call   *0x150fc
   12624:	88 45 f0             	mov    %al,0xfffffff0(%ebp)
   12627:	8b 46 18             	mov    0x18(%esi),%eax
   1262a:	40                   	inc    %eax
   1262b:	50                   	push   %eax
   1262c:	ff 15 fc 50 01 00    	call   *0x150fc
   12632:	88 45 f1             	mov    %al,0xfffffff1(%ebp)
   12635:	8b 46 18             	mov    0x18(%esi),%eax
   12638:	83 c0 02             	add    $0x2,%eax
   1263b:	50                   	push   %eax
   1263c:	ff 15 fc 50 01 00    	call   *0x150fc
   12642:	83 c4 0c             	add    $0xc,%esp
   12645:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   12648:	e9 aa fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   1264d:	81 fb 02 01 02 00    	cmp    $0x20102,%ebx
   12653:	0f 84 96 00 00 00    	je     126ef <_MiniportQueryInformation@24+0x3ff>
   12659:	81 fb 03 01 02 00    	cmp    $0x20103,%ebx
   1265f:	0f 85 61 fd ff ff    	jne    123c6 <_MiniportQueryInformation@24+0xd6>
   12665:	8b 96 1c 01 00 00    	mov    0x11c(%esi),%edx
   1266b:	8b 86 20 01 00 00    	mov    0x120(%esi),%eax
   12671:	01 d0                	add    %edx,%eax
   12673:	8b 9e 24 01 00 00    	mov    0x124(%esi),%ebx
   12679:	01 d8                	add    %ebx,%eax
   1267b:	8b 8e 28 01 00 00    	mov    0x128(%esi),%ecx
   12681:	01 c8                	add    %ecx,%eax
   12683:	8b 96 2c 01 00 00    	mov    0x12c(%esi),%edx
   12689:	01 d0                	add    %edx,%eax
   1268b:	8b 9e 30 01 00 00    	mov    0x130(%esi),%ebx
   12691:	01 d8                	add    %ebx,%eax
   12693:	8b 8e 34 01 00 00    	mov    0x134(%esi),%ecx
   12699:	01 c8                	add    %ecx,%eax
   1269b:	e9 7e fe ff ff       	jmp    1251e <_MiniportQueryInformation@24+0x22e>
   126a0:	8b 86 18 01 00 00    	mov    0x118(%esi),%eax
   126a6:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   126a9:	e9 49 fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   126ae:	c7 45 f0 07 00 00 00 	movl   $0x7,0xfffffff0(%ebp)
   126b5:	e9 3d fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   126ba:	bf 90 00 00 00       	mov    $0x90,%edi
   126bf:	c7 45 e8 00 30 01 00 	movl   $0x13000,0xffffffe8(%ebp)
   126c6:	e9 2c fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   126cb:	8b 86 4c 01 00 00    	mov    0x14c(%esi),%eax
   126d1:	8b 96 44 01 00 00    	mov    0x144(%esi),%edx
   126d7:	01 d0                	add    %edx,%eax
   126d9:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   126dc:	e9 16 fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   126e1:	8b 86 38 01 00 00    	mov    0x138(%esi),%eax
   126e7:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   126ea:	e9 08 fd ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   126ef:	8b 86 40 01 00 00    	mov    0x140(%esi),%eax
   126f5:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   126f8:	e9 fa fc ff ff       	jmp    123f7 <_MiniportQueryInformation@24+0x107>
   126fd:	8d 76 00             	lea    0x0(%esi),%esi

00012700 <_MiniportSetInformation@24>:

NDIS_STATUS
STDCALL
MiniportSetInformation(
    IN NDIS_HANDLE MiniportAdapterContext,
    IN NDIS_OID Oid,
    IN PVOID InformationBuffer,
    IN ULONG InformationBufferLength,
    OUT PULONG BytesRead,
    OUT PULONG BytesNeeded)
/*
 * FUNCTION: Set a miniport variable (OID)
 * ARGUMENTS:
 *     MiniportAdapterContext: context originally passed into NdisMSetAttributes
 *     Oid: the variable being set
 *     InformationBuffer: the data to set the variable to
 *     InformationBufferLength: number of bytes in InformationBuffer
 *     BytesRead: number of bytes read by us out of the buffer
 *     BytesNeeded: number of bytes required to satisfy the request if InformationBufferLength
 *                  is insufficient
 * RETURNS:
 *     NDIS_STATUS_SUCCESS on all requests
 * NOTES:
 *     - Called by NDIS at PASSIVE_LEVEL
 *     - verify buffer space as mentioned in previous function notes
 */
{
   12700:	55                   	push   %ebp
   12701:	89 e5                	mov    %esp,%ebp
   12703:	57                   	push   %edi
   12704:	56                   	push   %esi
   12705:	53                   	push   %ebx
   12706:	83 ec 14             	sub    $0x14,%esp
  ULONG GenericULONG;
  NDIS_STATUS Status   = NDIS_STATUS_SUCCESS;
   12709:	31 ff                	xor    %edi,%edi
   1270b:	8b 75 08             	mov    0x8(%ebp),%esi
   1270e:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;

  ASSERT(Adapter);

  PCNET_DbgPrint(("Called, OID 0x%x\n", Oid));

  NdisAcquireSpinLock(&Adapter->Lock);
   12711:	8d 46 04             	lea    0x4(%esi),%eax
   12714:	50                   	push   %eax
   12715:	56                   	push   %esi
   12716:	ff 15 f0 50 01 00    	call   *0x150f0

  switch (Oid) 
   1271c:	81 fb 0f 01 01 00    	cmp    $0x1010f,%ebx
   12722:	59                   	pop    %ecx
   12723:	58                   	pop    %eax
   12724:	74 5d                	je     12783 <_MiniportSetInformation@24+0x83>
   12726:	76 3e                	jbe    12766 <_MiniportSetInformation@24+0x66>
   12728:	81 fb 03 01 01 01    	cmp    $0x1010103,%ebx
   1272e:	0f 84 cc 00 00 00    	je     12800 <_MiniportSetInformation@24+0x100>
    {
    case OID_GEN_CURRENT_PACKET_FILTER:
      {
        /* Verify length */
        if (InformationBufferLength < sizeof(ULONG)) 
          {
            *BytesRead   = 0;
            *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
            Status       = NDIS_STATUS_INVALID_LENGTH;
            break;
          }

        NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));

        /* Check for properties the driver don't support */
        if (GenericULONG &
           (NDIS_PACKET_TYPE_ALL_FUNCTIONAL |
            NDIS_PACKET_TYPE_FUNCTIONAL     |
            NDIS_PACKET_TYPE_GROUP          |
            NDIS_PACKET_TYPE_MAC_FRAME      |
            NDIS_PACKET_TYPE_SMT            |
            NDIS_PACKET_TYPE_SOURCE_ROUTING)
           ) 
          {
            *BytesRead   = 4;
            *BytesNeeded = 0;
            Status       = NDIS_STATUS_NOT_SUPPORTED;
            break;
          }
            
        Adapter->CurrentPacketFilter = GenericULONG;

        /* FIXME: Set filter on hardware */

        break;
      }

    case OID_GEN_CURRENT_LOOKAHEAD:
      {
        /* Verify length */
        if (InformationBufferLength < sizeof(ULONG)) 
          {
            *BytesRead   = 0;
            *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
            Status = NDIS_STATUS_INVALID_LENGTH;
            break;
          }

        NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));

        if (GenericULONG > 1500)
          Status = NDIS_STATUS_INVALID_LENGTH;
        else
          Adapter->CurrentLookaheadSize = GenericULONG;

        break;
      }

    case OID_802_3_MULTICAST_LIST:
      {
        /* Verify length. Must be multiple of hardware address length */
        if ((InformationBufferLength % 6) != 0) 
          {
            *BytesRead   = 0;
            *BytesNeeded = 0;
            Status       = NDIS_STATUS_INVALID_LENGTH;
            break;
          }

        ASSERT((InformationBufferLength / 6) <= MAX_MULTICAST_ADDRESSES);

        /* Set new multicast address list */
        //NdisMoveMemory(Adapter->Addresses, InformationBuffer, InformationBufferLength);

        /* Update hardware */
        Status = MiSetMulticast(Adapter, InformationBuffer, InformationBufferLength / 6);

        break;
      }

    default:
      {
        PCNET_DbgPrint(("Invalid object ID (0x%X).\n", Oid));
        *BytesRead   = 0;
   12734:	8b 4d 18             	mov    0x18(%ebp),%ecx
        *BytesNeeded = 0;
   12737:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1273a:	c7 01 00 00 00 00    	movl   $0x0,(%ecx)
   12740:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
        Status       = NDIS_STATUS_NOT_SUPPORTED;
   12746:	bf bb 00 00 c0       	mov    $0xc00000bb,%edi
        break;
      }
    }

  if (Status == NDIS_STATUS_SUCCESS) 
    {
      *BytesRead   = InformationBufferLength;
      *BytesNeeded = 0;
    }

  NdisReleaseSpinLock(&Adapter->Lock);
   1274b:	31 c0                	xor    %eax,%eax
   1274d:	51                   	push   %ecx
   1274e:	51                   	push   %ecx
   1274f:	8a 46 04             	mov    0x4(%esi),%al
   12752:	50                   	push   %eax
   12753:	56                   	push   %esi
   12754:	ff 15 f4 50 01 00    	call   *0x150f4

  PCNET_DbgPrint(("Leaving. Status (0x%X).\n", Status));

  return Status;
}
   1275a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1275d:	89 f8                	mov    %edi,%eax
   1275f:	5b                   	pop    %ebx
   12760:	5e                   	pop    %esi
   12761:	5f                   	pop    %edi
   12762:	5d                   	pop    %ebp
   12763:	c2 18 00             	ret    $0x18
   12766:	81 fb 0e 01 01 00    	cmp    $0x1010e,%ebx
   1276c:	75 c6                	jne    12734 <_MiniportSetInformation@24+0x34>
   1276e:	83 7d 14 03          	cmpl   $0x3,0x14(%ebp)
   12772:	0f 87 b3 00 00 00    	ja     1282b <_MiniportSetInformation@24+0x12b>
   12778:	8b 45 18             	mov    0x18(%ebp),%eax
   1277b:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12781:	eb 4d                	jmp    127d0 <_MiniportSetInformation@24+0xd0>
   12783:	83 7d 14 03          	cmpl   $0x3,0x14(%ebp)
   12787:	76 3e                	jbe    127c7 <_MiniportSetInformation@24+0xc7>
   12789:	8b 4d 10             	mov    0x10(%ebp),%ecx
   1278c:	8b 01                	mov    (%ecx),%eax
   1278e:	3d dc 05 00 00       	cmp    $0x5dc,%eax
   12793:	77 4a                	ja     127df <_MiniportSetInformation@24+0xdf>
   12795:	89 86 d0 00 00 00    	mov    %eax,0xd0(%esi)
   1279b:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1279e:	8b 55 18             	mov    0x18(%ebp),%edx
   127a1:	8b 4d 14             	mov    0x14(%ebp),%ecx
   127a4:	89 0a                	mov    %ecx,(%edx)
   127a6:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   127ac:	31 c0                	xor    %eax,%eax
   127ae:	51                   	push   %ecx
   127af:	51                   	push   %ecx
   127b0:	8a 46 04             	mov    0x4(%esi),%al
   127b3:	50                   	push   %eax
   127b4:	56                   	push   %esi
   127b5:	ff 15 f4 50 01 00    	call   *0x150f4
   127bb:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   127be:	89 f8                	mov    %edi,%eax
   127c0:	5b                   	pop    %ebx
   127c1:	5e                   	pop    %esi
   127c2:	5f                   	pop    %edi
   127c3:	5d                   	pop    %ebp
   127c4:	c2 18 00             	ret    $0x18
   127c7:	8b 4d 18             	mov    0x18(%ebp),%ecx
   127ca:	c7 01 00 00 00 00    	movl   $0x0,(%ecx)
   127d0:	8b 55 14             	mov    0x14(%ebp),%edx
   127d3:	b8 04 00 00 00       	mov    $0x4,%eax
   127d8:	29 d0                	sub    %edx,%eax
   127da:	8b 55 1c             	mov    0x1c(%ebp),%edx
   127dd:	89 02                	mov    %eax,(%edx)
   127df:	bf 14 00 01 c0       	mov    $0xc0010014,%edi
   127e4:	31 c0                	xor    %eax,%eax
   127e6:	51                   	push   %ecx
   127e7:	51                   	push   %ecx
   127e8:	8a 46 04             	mov    0x4(%esi),%al
   127eb:	50                   	push   %eax
   127ec:	56                   	push   %esi
   127ed:	ff 15 f4 50 01 00    	call   *0x150f4
   127f3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   127f6:	89 f8                	mov    %edi,%eax
   127f8:	5b                   	pop    %ebx
   127f9:	5e                   	pop    %esi
   127fa:	5f                   	pop    %edi
   127fb:	5d                   	pop    %ebp
   127fc:	c2 18 00             	ret    $0x18
   127ff:	90                   	nop    
   12800:	ba 06 00 00 00       	mov    $0x6,%edx
   12805:	8b 45 14             	mov    0x14(%ebp),%eax
   12808:	89 d1                	mov    %edx,%ecx
   1280a:	31 d2                	xor    %edx,%edx
   1280c:	f7 f1                	div    %ecx
   1280e:	85 d2                	test   %edx,%edx
   12810:	74 47                	je     12859 <_MiniportSetInformation@24+0x159>
   12812:	8b 45 18             	mov    0x18(%ebp),%eax
   12815:	8b 55 1c             	mov    0x1c(%ebp),%edx
   12818:	bf 14 00 01 c0       	mov    $0xc0010014,%edi
   1281d:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12823:	c7 02 00 00 00 00    	movl   $0x0,(%edx)
   12829:	eb b9                	jmp    127e4 <_MiniportSetInformation@24+0xe4>
   1282b:	8b 4d 10             	mov    0x10(%ebp),%ecx
   1282e:	8b 01                	mov    (%ecx),%eax
   12830:	a9 50 f0 00 00       	test   $0xf050,%eax
   12835:	74 17                	je     1284e <_MiniportSetInformation@24+0x14e>
   12837:	8b 45 18             	mov    0x18(%ebp),%eax
   1283a:	8b 55 1c             	mov    0x1c(%ebp),%edx
   1283d:	c7 00 04 00 00 00    	movl   $0x4,(%eax)
   12843:	c7 02 00 00 00 00    	movl   $0x0,(%edx)
   12849:	e9 f8 fe ff ff       	jmp    12746 <_MiniportSetInformation@24+0x46>
   1284e:	89 86 cc 00 00 00    	mov    %eax,0xcc(%esi)
   12854:	e9 42 ff ff ff       	jmp    1279b <_MiniportSetInformation@24+0x9b>
   12859:	50                   	push   %eax
   1285a:	8b 45 14             	mov    0x14(%ebp),%eax
   1285d:	ba ab aa aa aa       	mov    $0xaaaaaaab,%edx
   12862:	f7 e2                	mul    %edx
   12864:	c1 ea 02             	shr    $0x2,%edx
   12867:	52                   	push   %edx
   12868:	8b 7d 10             	mov    0x10(%ebp),%edi
   1286b:	57                   	push   %edi
   1286c:	56                   	push   %esi
   1286d:	e8 6e f9 ff ff       	call   121e0 <_MiSetMulticast@12>
   12872:	89 c7                	mov    %eax,%edi
   12874:	5b                   	pop    %ebx
   12875:	85 c0                	test   %eax,%eax
   12877:	0f 85 ce fe ff ff    	jne    1274b <_MiniportSetInformation@24+0x4b>
   1287d:	e9 19 ff ff ff       	jmp    1279b <_MiniportSetInformation@24+0x9b>
   12882:	90                   	nop    
   12883:	90                   	nop    
   12884:	90                   	nop    
   12885:	90                   	nop    
   12886:	90                   	nop    
   12887:	90                   	nop    
   12888:	90                   	nop    
   12889:	90                   	nop    
   1288a:	90                   	nop    
   1288b:	90                   	nop    
   1288c:	90                   	nop    
   1288d:	90                   	nop    
   1288e:	90                   	nop    
   1288f:	90                   	nop    

00012890 <_NdisReadPciSlotInformation@20>:
   12890:	ff 25 58 51 01 00    	jmp    *0x15158
   12896:	90                   	nop    
   12897:	90                   	nop    
	...

000128a0 <_NdisWritePciSlotInformation@20>:
   128a0:	ff 25 60 51 01 00    	jmp    *0x15160
   128a6:	90                   	nop    
   128a7:	90                   	nop    
	...

000128b0 <_NdisMAllocateSharedMemory@20>:
   128b0:	ff 25 24 51 01 00    	jmp    *0x15124
   128b6:	90                   	nop    
   128b7:	90                   	nop    
	...

000128c0 <_NdisMFreeSharedMemory@24>:
   128c0:	ff 25 38 51 01 00    	jmp    *0x15138
   128c6:	90                   	nop    
   128c7:	90                   	nop    
	...

000128d0 <_NdisMCancelTimer@8>:
   128d0:	ff 25 28 51 01 00    	jmp    *0x15128
   128d6:	90                   	nop    
   128d7:	90                   	nop    
	...

000128e0 <_NdisMSynchronizeWithInterrupt@12>:
   128e0:	ff 25 54 51 01 00    	jmp    *0x15154
   128e6:	90                   	nop    
   128e7:	90                   	nop    
	...

000128f0 <_NdisMDeregisterInterrupt@4>:
   128f0:	ff 25 2c 51 01 00    	jmp    *0x1512c
   128f6:	90                   	nop    
   128f7:	90                   	nop    
	...

00012900 <_NdisMDeregisterIoPortRange@16>:
   12900:	ff 25 30 51 01 00    	jmp    *0x15130
   12906:	90                   	nop    
   12907:	90                   	nop    
	...

00012910 <_NdisMFreeMapRegisters@4>:
   12910:	ff 25 34 51 01 00    	jmp    *0x15134
   12916:	90                   	nop    
   12917:	90                   	nop    
	...

00012920 <_NdisFreeMemory@12>:
   12920:	ff 25 18 51 01 00    	jmp    *0x15118
   12926:	90                   	nop    
   12927:	90                   	nop    
	...

00012930 <_NdisAllocateMemoryWithTag@12>:
   12930:	ff 25 14 51 01 00    	jmp    *0x15114
   12936:	90                   	nop    
   12937:	90                   	nop    
	...

00012940 <_NdisMSetAttributesEx@20>:
   12940:	ff 25 4c 51 01 00    	jmp    *0x1514c
   12946:	90                   	nop    
   12947:	90                   	nop    
	...

00012950 <_NdisMInitializeTimer@16>:
   12950:	ff 25 3c 51 01 00    	jmp    *0x1513c
   12956:	90                   	nop    
   12957:	90                   	nop    
	...

00012960 <_NdisMSetPeriodicTimer@8>:
   12960:	ff 25 50 51 01 00    	jmp    *0x15150
   12966:	90                   	nop    
   12967:	90                   	nop    
	...

00012970 <_NdisMRegisterIoPortRange@16>:
   12970:	ff 25 44 51 01 00    	jmp    *0x15144
   12976:	90                   	nop    
   12977:	90                   	nop    
	...

00012980 <_NdisMAllocateMapRegisters@20>:
   12980:	ff 25 20 51 01 00    	jmp    *0x15120
   12986:	90                   	nop    
   12987:	90                   	nop    
	...

00012990 <_NdisMRegisterInterrupt@28>:
   12990:	ff 25 40 51 01 00    	jmp    *0x15140
   12996:	90                   	nop    
   12997:	90                   	nop    
	...

000129a0 <_NDIS_BUFFER_TO_SPAN_PAGES@4>:
   129a0:	ff 25 10 51 01 00    	jmp    *0x15110
   129a6:	90                   	nop    
   129a7:	90                   	nop    
	...

000129b0 <_NdisInitializeWrapper@16>:
   129b0:	ff 25 1c 51 01 00    	jmp    *0x1511c
   129b6:	90                   	nop    
   129b7:	90                   	nop    
	...

000129c0 <_NdisMRegisterMiniport@12>:
   129c0:	ff 25 48 51 01 00    	jmp    *0x15148
   129c6:	90                   	nop    
   129c7:	90                   	nop    
	...

000129d0 <_NdisTerminateWrapper@8>:
   129d0:	ff 25 5c 51 01 00    	jmp    *0x1515c
   129d6:	90                   	nop    
   129d7:	90                   	nop    
	...

000129e0 <@KefAcquireSpinLockAtDpcLevel@4>:
   129e0:	ff 25 6c 51 01 00    	jmp    *0x1516c
   129e6:	90                   	nop    
   129e7:	90                   	nop    
	...

000129f0 <@KefReleaseSpinLockFromDpcLevel@4>:
   129f0:	ff 25 70 51 01 00    	jmp    *0x15170
   129f6:	90                   	nop    
   129f7:	90                   	nop    
	...

00012a00 <_KeInitializeSpinLock@4>:
   12a00:	ff 25 74 51 01 00    	jmp    *0x15174
   12a06:	90                   	nop    
   12a07:	90                   	nop    
	...

00012a10 <_MmMapLockedPages@8>:
   12a10:	ff 25 78 51 01 00    	jmp    *0x15178
   12a16:	90                   	nop    
   12a17:	90                   	nop    
	...

00012a20 <_memcpy>:
   12a20:	ff 25 7c 51 01 00    	jmp    *0x1517c
   12a26:	90                   	nop    
   12a27:	90                   	nop    
	...

00012a30 <_memset>:
   12a30:	ff 25 80 51 01 00    	jmp    *0x15180
   12a36:	90                   	nop    
   12a37:	90                   	nop    
	...

00012a40 <_WRITE_PORT_USHORT@8>:
   12a40:	ff 25 04 51 01 00    	jmp    *0x15104
   12a46:	90                   	nop    
   12a47:	90                   	nop    
	...

00012a50 <_READ_PORT_USHORT@4>:
   12a50:	ff 25 00 51 01 00    	jmp    *0x15100
   12a56:	90                   	nop    
   12a57:	90                   	nop    
	...

00012a60 <_READ_PORT_UCHAR@4>:
   12a60:	ff 25 fc 50 01 00    	jmp    *0x150fc
   12a66:	90                   	nop    
   12a67:	90                   	nop    
	...

00012a70 <_KeStallExecutionProcessor@4>:
   12a70:	ff 25 f8 50 01 00    	jmp    *0x150f8
   12a76:	90                   	nop    
   12a77:	90                   	nop    
	...

00012a80 <_KeAcquireSpinLock@8>:
   12a80:	ff 25 f0 50 01 00    	jmp    *0x150f0
   12a86:	90                   	nop    
   12a87:	90                   	nop    
	...

00012a90 <_KeReleaseSpinLock@8>:
   12a90:	ff 25 f4 50 01 00    	jmp    *0x150f4
   12a96:	90                   	nop    
   12a97:	90                   	nop    
	...

00012aa0 <__CTOR_LIST__>:
   12aa0:	ff                   	(bad)  
   12aa1:	ff                   	(bad)  
   12aa2:	ff                   	(bad)  
   12aa3:	ff 00                	incl   (%eax)
   12aa5:	00 00                	add    %al,(%eax)
	...

00012aa8 <__DTOR_LIST__>:
   12aa8:	ff                   	(bad)  
   12aa9:	ff                   	(bad)  
   12aaa:	ff                   	(bad)  
   12aab:	ff 00                	incl   (%eax)
   12aad:	00 00                	add    %al,(%eax)
	...
